diff --git a/Justfile b/Justfile
index ef884f47a1..2d4e741659 100644
--- a/Justfile
+++ b/Justfile
@@ -138,9 +138,7 @@ docs-api:
 
 # Regenerate Parquet Thrift PHP classes.
 gen-thrift: && fix
-    grep -q 'namespace php Flow.Parquet.ThriftModel' src/lib/parquet/src/Flow/Parquet/Resources/Thrift/parquet.thrift || { echo "Flow php namespace not found in thrift definition!"; exit 1; }
-    rm src/lib/parquet/src/Flow/Parquet/ThriftModel/*.php
-    thrift --gen php --out src/lib/parquet/src src/lib/parquet/src/Flow/Parquet/Resources/Thrift/parquet.thrift
+    php bin/thrift.php parquet
 
 # Regenerate PostgreSQL pg_query Protobuf PHP classes.
 gen-protobuf-pg: && fix
diff --git a/bin/docs.php b/bin/docs.php
index 833a0db5f7..0ac9d5ff8e 100755
--- a/bin/docs.php
+++ b/bin/docs.php
@@ -73,6 +73,7 @@ public function execute(InputInterface $input, OutputInterface $output): int
             __DIR__ . '/../src/adapter/etl-adapter-xml/src/Flow/ETL/Adapter/XML/functions.php',
             __DIR__ . '/../src/lib/filesystem/src/Flow/Filesystem/DSL/functions.php',
             __DIR__ . '/../src/lib/types/src/Flow/Types/DSL/functions.php',
+            __DIR__ . '/../src/lib/parquet/src/Flow/Parquet/DSL/functions.php',
             __DIR__ . '/../src/lib/postgresql/src/Flow/PostgreSql/DSL/schema.php',
             __DIR__ . '/../src/lib/postgresql/src/Flow/PostgreSql/DSL/query.php',
             __DIR__ . '/../src/lib/postgresql/src/Flow/PostgreSql/DSL/condition.php',
diff --git a/bin/thrift.php b/bin/thrift.php
new file mode 100755
index 0000000000..241dff0b5b
--- /dev/null
+++ b/bin/thrift.php
@@ -0,0 +1,100 @@
+#!/usr/bin/env php
+<?php
+
+declare(strict_types=1);
+
+use Symfony\Component\Console\Application;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Process\ExecutableFinder;
+use Symfony\Component\Process\Process;
+
+use function Flow\Types\DSL\type_string;
+
+require __DIR__ . '/../vendor/autoload.php';
+
+$application = new Application('Flow-PHP - Thrift');
+
+$application->addCommand(new class extends Command {
+    public function configure(): void
+    {
+        $this
+            ->setName('parquet')
+            ->setDescription('Regenerates the Parquet ThriftModel classes from parquet.thrift.')
+            ->addOption(
+                'thrift',
+                null,
+                InputOption::VALUE_REQUIRED,
+                'Thrift compiler binary, found in PATH when omitted',
+            );
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $source = __DIR__ . '/../src/lib/parquet/src';
+        $idl = $source . '/Flow/Parquet/Resources/Thrift/parquet.thrift';
+        $models = $source . '/Flow/Parquet/ThriftModel';
+
+        $thrift = $input->getOption('thrift') === null
+            ? (new ExecutableFinder())->find('thrift')
+            : type_string()->assert($input->getOption('thrift'));
+
+        if (!is_string($thrift) || !is_executable($thrift)) {
+            $output->writeln('<error>Thrift compiler not found, pass an executable with --thrift</error>');
+
+            return Command::FAILURE;
+        }
+
+        if (!str_contains((string) file_get_contents($idl), 'namespace php Flow.Parquet.ThriftModel')) {
+            $output->writeln('<error>Flow php namespace not found in thrift definition!</error>');
+
+            return Command::FAILURE;
+        }
+
+        foreach (glob($models . '/*.php') ?: [] as $file) {
+            unlink($file);
+        }
+
+        (new Process([$thrift, '--gen', 'php', '--out', $source, $idl]))->mustRun(
+            static fn(string $type, string $buffer) => $output->write($buffer),
+        );
+
+        // the Thrift compiler types every field non-null; a field the IDL does not require is null when a file leaves it out
+        foreach (glob($models . '/*.php') ?: [] as $file) {
+            $class = 'Flow\\Parquet\\ThriftModel\\' . basename($file, '.php');
+
+            if (!class_exists($class) || !property_exists($class, '_TSPEC')) {
+                continue;
+            }
+
+            /** @var array<int, array{var: string, isRequired: bool}> $spec */
+            $spec = (new ReflectionProperty($class, '_TSPEC'))->getValue();
+            $model = (string) file_get_contents($file);
+            $rewritten = $model;
+
+            foreach ($spec as $field) {
+                if ($field['isRequired']) {
+                    continue;
+                }
+
+                $rewritten = (string) preg_replace(
+                    '/(\* @var )(?!null\|)([^\n]+)(\n\s*\*\/\n\s*public \$'
+                    . preg_quote($field['var'], '/')
+                    . ' = null;)/',
+                    '$1null|$2$3',
+                    $rewritten,
+                );
+            }
+
+            if ($rewritten !== $model) {
+                file_put_contents($file, $rewritten);
+            }
+        }
+
+        return Command::SUCCESS;
+    }
+});
+
+$application->run();
diff --git a/composer.json b/composer.json
index 48de3ffb0d..1bca0798ee 100644
--- a/composer.json
+++ b/composer.json
@@ -260,6 +260,7 @@
             "src/lib/filesystem/src/Flow/Filesystem/DSL/functions.php",
             "src/lib/parquet/src/Flow/Parquet/functions.php",
             "src/lib/parquet/src/Flow/Parquet/Binary/functions.php",
+            "src/lib/parquet/src/Flow/Parquet/DSL/functions.php",
             "src/lib/parquet/src/stubs.php",
             "src/lib/postgresql/src/Flow/PostgreSql/DSL/client.php",
             "src/lib/postgresql/src/Flow/PostgreSql/DSL/condition.php",
diff --git a/documentation/components/adapters/parquet.md b/documentation/components/adapters/parquet.md
index 862480ec79..06d5153c8b 100644
--- a/documentation/components/adapters/parquet.md
+++ b/documentation/components/adapters/parquet.md
@@ -73,3 +73,72 @@ data_frame()
     ->write(to_output())
     ->run();
 ```
+
+A `UINT_64` column reads as `numeric_string` (`'18446744073709551615'` is past `PHP_INT_MAX`). A `numeric_string`
+column is written as a parquet `STRING`; write `UINT_64` through the lib with an explicit schema:
+
+```php
+<?php
+
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\{FlatColumn, LogicalType, PhysicalType};
+use Flow\Parquet\Writer;
+
+(new Writer())->write(
+    __DIR__ . '/ids.parquet',
+    Schema::with(new FlatColumn('id', PhysicalType::INT64, logicalType: LogicalType::integer(64, false))),
+    [['id' => 7], ['id' => '18446744073709551615']],
+);
+```
+
+## Filter pushdown
+
+A `filter()` directly over `from_parquet()` moves into the reader, which returns only matching rows: row groups whose
+statistics prove that no row matches are skipped, and a `limit()` after the filter stops the read at that many
+matching rows:
+
+```php
+<?php
+
+use function Flow\ETL\Adapter\Parquet\from_parquet;
+use function Flow\ETL\DSL\{data_frame, lit, ref, to_output};
+
+data_frame()
+    ->read(from_parquet(__DIR__ . '/orders/*.parquet'))
+    ->filter(ref('id')->greaterThan(lit(1000))->and(ref('status')->equals(lit('paid'))))
+    ->limit(10)
+    ->write(to_output())
+    ->run();
+```
+
+Each part of an `and()` is pushed on its own when it compares a file column with a literal it can compare exactly.
+
+Pushed:
+
+- `equals`, `notEquals`, `same`, `notSame`, `lessThan`, `lessThanEqual`, `greaterThan`, `greaterThanEqual`,
+  `between`, `isIn` (literal list), `startsWith`, `isNull`, `isNotNull`, and `not()`/`and()`/`or()` of those
+- an int literal on a float column up to 2^53, an integral float on an int column below 2^53
+- a `date` literal on a `datetime` column and the reverse
+- a digit string (`lit('1000')`) on a `numeric_string` (`UINT_64`) column
+
+Evaluated on the rows read:
+
+- other functions, two columns compared, a literal of another type
+- `json` columns (except `isNull`/`isNotNull`), ordering on `uuid`
+- a column the file stores as another type than the read
+
+Partition columns list fewer files instead ([partitioning](/documentation/components/core/partitioning.md)).
+
+`explain()` shows the filter and the limit under `Read`, not what the reader skipped:
+
+```
+#3 Result
+│  Rows this plan hands out: to the trigger, or to the node reading it
+└─ #2 Limit
+   │  Limit: 10
+   └─ #1 Read
+         Extractor: ParquetExtractor
+         Source: file:///orders/*.parquet
+         Limit: 10
+         Filter: All
+```
diff --git a/documentation/components/core/core.md b/documentation/components/core/core.md
index 02254f9456..01d6a5f377 100644
--- a/documentation/components/core/core.md
+++ b/documentation/components/core/core.md
@@ -67,7 +67,7 @@ Outputs
 ├─ #4 Result
 │  │  Rows this plan hands out: to the trigger, or to the node reading it
 │  └─ #3 Select
-│     │  Columns: id, email
+│     │  Keeps only: id, email
 │     └─ #2 Filter
 │        │  Condition: IsNotNull
 │        └─ #1 Read
@@ -129,7 +129,7 @@ echo $dataFrame->explain()->toString(format: Format::flow);
 └─ #2 Filter
    │  Condition: IsNotNull
    ├─ #3 Select
-   │  │  Columns: id, email
+   │  │  Keeps only: id, email
    │  └─ #4 Result
    │        Rows this plan hands out: to the trigger, or to the node reading it
    └─ #5 Write
@@ -154,7 +154,7 @@ echo $dataFrame->explain()->toString(format: Format::boxes);
 ┌─────────────┴─────────────┐┌─────────────┴─────────────┐
 │         #3 Select         ││         #2 Filter         │
 │   ────────────────────    ││         (shared)          │
-│    Columns: id, email     ││                           │
+│   Keeps only: id, email   ││                           │
 └─────────────┬─────────────┘└───────────────────────────┘
 ┌─────────────┴─────────────┐
 │         #2 Filter         │
diff --git a/documentation/components/core/partitioning.md b/documentation/components/core/partitioning.md
index 186cc68419..feb42eb533 100644
--- a/documentation/components/core/partitioning.md
+++ b/documentation/components/core/partitioning.md
@@ -268,8 +268,10 @@ it from the file schema (Parquet, Floe), so `filter(ref('date')->between(lit($fr
 
 ### Partition Pruning
 
-The optimizer pushes a `filter()` that reads only partition columns into the source, so whole directories
-are skipped; a filter on a body column still reads everything and then discards. A partition column renamed
+The optimizer moves a `filter()` into the file source, which returns only matching rows. A filter that reads only
+partition columns skips whole directories; a filter on a body column reads every file and drops the rows it does not
+match (Parquet skips row groups, see [filter pushdown](/documentation/components/adapters/parquet.md#filter-pushdown)).
+A `limit()` after the filter reaches the source with it ([filter pushdown](/documentation/components/adapters/parquet.md#filter-pushdown)). A partition column renamed
 with `rename()` or copied with `withEntry('day', ref('date'))` is still pruned; any other redefinition of it
 stops the push. A filter whose answer can change between two evaluations - `call()`, `now()`, `uuid()`,
 `to_date_time()` with a format that leaves fields out (`'Y-m-d'`) - still filters rows but prunes nothing.
@@ -283,6 +285,7 @@ use function Flow\ETL\DSL\{data_frame, lit, ref, to_output};
 data_frame()
     ->read(from_csv(__DIR__ . '/output/date=*/department=*/*.csv'))
     ->filter(ref('date')->greaterThanEqual(lit('2024-01-01')))
+    ->limit(10)
     ->write(to_output())
     ->run();
 ```
diff --git a/documentation/components/extensions/arrow-ext.md b/documentation/components/extensions/arrow-ext.md
index f79d40880f..1c2dcdc35d 100644
--- a/documentation/components/extensions/arrow-ext.md
+++ b/documentation/components/extensions/arrow-ext.md
@@ -92,18 +92,23 @@ use Flow\Parquet\Engine\{RustParquetFileReader, RustParquetFileWriter};
 use Flow\Parquet\Engine\Arrow\{OptionsConverter, SchemaConverter};
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\ParquetFile\Index\StreamIndexes;
+use Flow\Parquet\Reader\ReadPlan;
 
 use function Flow\Filesystem\DSL\{native_local_filesystem, path};
 
 $filesystem = native_local_filesystem();
 
 $file = new RustParquetFileReader($filesystem->readFrom(path('data.parquet'))); // Flow\Parquet\ParquetFileReader, one footer read
-$file->rowsNumber();
-$file->schema();                                                      // Flow\Parquet\ParquetFile\Schema
-$file->metadata();                                                    // Flow\Parquet\ParquetFile\Metadata
-$file->thrift();                                                      // Flow\Parquet\ThriftModel\FileMetaData
-
-foreach ($file->readColumns(['id', 'name'], 1_000, null, null) as $chunk) { // RustColumnsReader, an Iterator that streams once
+$footer = $file->footer();                                            // Flow\Parquet\Engine\RustParquetFooter, readable after close()
+$footer->rowsNumber();
+$footer->schema();                                                    // Flow\Parquet\ParquetFile\Schema
+$footer->metadata();                                                  // Flow\Parquet\ParquetFile\Metadata
+$footer->thrift();                                                    // Flow\Parquet\ThriftModel\FileMetaData
+$indexes = new StreamIndexes($footer, $filesystem->readFrom(path('data.parquet')));  // page indexes, read on demand
+$plan = ReadPlan::window($footer->rowsNumber(), $indexes, offset: 10, limit: 100);  // rows 10-109
+
+foreach ($file->readColumns(['id', 'name'], 1_000, $plan) as $chunk) { // RustColumnsReader, an Iterator that streams once
     // ['id' => [1, 2, ...], 'name' => ['a', 'b', ...]]
 }
 
@@ -118,7 +123,7 @@ $writer->writeBatch([['id' => 1, 'name' => 'a']]);   // an array or any Traversa
 $writer->writeColumns(['id' => [2, 3], 'name' => ['b', null]]);
 $writer->close();                              // footer, then the stream closed
 
-$batches = new RustBatchReader($file, ['id', 'name'], 1_000, null, null); // batch size, offset, limit
+$batches = new RustBatchReader($file, ['id', 'name'], 1_000, $plan); // batch size, rows to read
 $batches->schema();                            // Flow\Arrow\RustArrowSchema
 $batches->next();                              // Flow\Arrow\RustParquetBatch, null after the last
 ```
diff --git a/documentation/components/libs/parquet.md b/documentation/components/libs/parquet.md
index 37b52280a7..49b89484c2 100644
--- a/documentation/components/libs/parquet.md
+++ b/documentation/components/libs/parquet.md
@@ -148,10 +148,10 @@ invalid file throws `InvalidArgumentException` `Given file is not valid Parquet
 
 There are several things we can read from parquet file:
 
-- `ParquetFile::values(array $columns = [], ?int $limit = null, ?int $offset = null) : \Generator`
-- `ParquetFile::columns(int $batchSize, array $columns = [], ?int $limit = null, ?int $offset = null) : \Generator`
+- `ParquetFile::values(Query $query = new Query()) : \Generator` - rows, one by one
+- `ParquetFile::columns(Query $query = new Query(), int $batchSize = 1024) : \Generator` - columns, in batches
 - `ParquetFile::metadata() : Metadata`
-- `ParquetFile::schema() : Schema` - shortcut for `ParquetFile::metadata()->schema()`
+- `ParquetFile::schema() : Schema` - the file schema, without building row-group metadata
 - `ParquetFile::close() : void` - closes the reader and its stream
 
 ### Reading the whole file:
@@ -171,12 +171,12 @@ foreach ($file->values() as $row) {
 
 ```php
 use Flow\Parquet\Reader;
+use function Flow\Parquet\DSL\parquet_query;
 
-$reader = new Reader();
+$file = (new Reader())->read('path/to/file.parquet');
 
-$file = $reader->read('path/to/file.parquet');
-foreach ($file->values(["column_1", "column_2"]) as $row) {
-    // do something with $row
+foreach ($file->values(parquet_query()->select('column_1', 'column_2')) as $row) {
+    // ['column_1' => ..., 'column_2' => ...]
 }
 ```
 
@@ -187,29 +187,88 @@ foreach ($file->values(["column_1", "column_2"]) as $row) {
 > To achieve the best results, we will need to play a bit with Writer options (covered later).
 
 ```php
-use Flow\Parquet\Reader;
+foreach ($file->values(parquet_query()->select('column_1')->offset(1000)->limit(100)) as $row) {
+    // rows 1000-1099
+}
+```
 
-$reader = new Reader();
+### Reading columns in batches
 
-$file = $reader->read('path/to/file.parquet');
-foreach ($file->values(["column_1", "column_2"], limit: 100, offset: 1000) as $row) {
-    // do something with $row
+```php
+foreach ($file->columns(parquet_query()->select('column_1', 'column_2'), batchSize: 1000) as $chunk) {
+    // ['column_1' => [...up to 1000 values], 'column_2' => [...]]
 }
 ```
 
-### Reading columns in batches
+### Filtering reads
 
 ```php
 use Flow\Parquet\Reader;
+use function Flow\Parquet\DSL\{parquet_column, parquet_query};
 
 $file = (new Reader())->read('path/to/file.parquet');
 
-foreach ($file->columns(batchSize: 1000, columns: ["column_1", "column_2"]) as $chunk) {
-    // $chunk = ['column_1' => [...up to 1000 values], 'column_2' => [...]]
+$query = parquet_query()
+    ->select('id', 'country')
+    ->where(
+        parquet_column('country')->equals('PL')
+            ->and(parquet_column('user.age')->lessThan(18)->negate())
+            ->and(parquet_column('status')->in(['new', 'paid'])->or(parquet_column('note')->isNull())),
+    )
+    ->offset(20)
+    ->limit(10);
+
+foreach ($file->values($query) as $row) {
+    // only matching rows: the 21st to the 30th match
 }
 ```
 
-`limit` and `offset` work as in `values()`.
+The rows returned are exactly the matching ones; offset and limit count matching rows. Row groups and pages whose
+statistics (column chunk statistics, the [page index](#page-index)) prove no row matches are never read - both engines
+skip the same ones and read a kept page's bytes alone. A second `where()` narrows the first.
+
+| Method on `parquet_column($path)`                                            | Filter                   |
+|------------------------------------------------------------------------------|--------------------------|
+| `equals`, `lessThan`, `lessThanOrEqual`, `greaterThan`, `greaterThanOrEqual` | `Comparison`             |
+| `notEquals`                                                                  | `Not` of `equals`        |
+| `in(array)`, `notIn(array)`                                                  | `In`, `Not` of `In`      |
+| `isNull()`, `isNotNull()`                                                    | `IsNull`, its `Not`      |
+| `startsWith(string)`                                                         | `StartsWith`             |
+
+- `->and()`, `->or()`, `->negate()` on any filter build `All`, `Any`, `Not`; `new All(...$filters)` and
+  `new Any(...$filters)` combine a list (namespace `Flow\Parquet\Filter`).
+- `$path` names a leaf through structs (`'user.address.city'`); a column the file lacks reads as null. A leaf inside a
+  list or a map is refused (`InvalidArgumentException`): a row holds no single value there.
+- Semantics are SQL's: a comparison on null is null, `NOT` null is null, only true keeps a row. Floats follow IEEE 754
+  (`NaN` matches nothing, `-0.0` equals `0.0`), strings compare in byte order (`'10' < '9'`), `UINT_64` values
+  numerically, date-times by instant. A literal of another kind than the column's values (a string on an `INT64`
+  column) matches nothing, under `->negate()` too.
+- Literals: scalars, `DateTimeInterface`, `Stringable` (uuids); `null` (use `isNull()`) and `NaN` are refused.
+- Files written without `column_orders` (older flow-php versions) are never pruned, only filtered. The statistics a file
+  holds are set by the writer options in [Statistics](#statistics).
+
+#### Reading with a ReadPlan
+
+```php
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Reader\ReadPlanner;
+use function Flow\Parquet\DSL\parquet_column;
+
+$filter = parquet_column('id')->greaterThan(100);
+$plan = (new ReadPlanner())->plan(
+    $file->reader()->footer(),
+    $file->indexes(),
+    BoundFilter::bind($filter, $file->schema(), $file->options()),
+    limit: 10,                     // rows kept by $plan->rowFilter, refused unless it is the whole filter
+);
+
+foreach ($file->reader()->readColumns(['id'], 1024, $plan) as $batch) {
+    // only rows matching $plan->rowFilter
+}
+```
+
+`ReadPlan::$rowFilter` holds the conjuncts the file compares exactly; rows come back matching them, a superset of the
+query's matches when they are not the whole filter.
 
 ## Writing Parquet Files
 
@@ -331,15 +390,24 @@ $writer->close();
 
 ### Writer Options
 
-- `DICTIONARY_PAGE_MIN_CARDINALITY_RATION` - default '0.4' - minimum ratio of unique values to total values for a column
-  to have dictionary encoding.
-- `DICTIONARY_PAGE_SIZE` - default: `1Mb` - maximum size of dictionary page.
+- `COLUMN_INDEX_TRUNCATE_LENGTH` - default: `64` - bytes a string/binary page's min/max in the column index are cut to.
+- `DICTIONARY_PAGE_SIZE` - default: `1Mb` - maximum size of dictionary page; the pages of a column chunk after it is
+  reached are written `PLAIN`.
 - `GZIP_COMPRESSION_LEVEL` - default: `9` - compression level for GZIP compression (applied only when GZIP compression
   is enabled).
+- `COLUMNS_BLOOM_FILTERS` - default: `null` - `BloomFilterOptions` by column flat path: those columns get a bloom filter
+  per row group ([Bloom filters](#bloom-filters)).
+- `PAGE_HEADER_STATISTICS` - default: `false` - data page headers carry the page's statistics (at `StatisticsLevel::PAGE`).
+- `PAGE_MAXIMUM_ROWS_COUNT` - default: `1000` - rows per data page: the PHP writer closes a page at exactly that many;
+  the arrow writer treats it as a target, checked between write batches, so its pages can hold more. Smaller pages let
+  the page index skip more of a filtered read.
 - `PAGE_SIZE_BYTES` - default: `128Kb` - maximum size of data page.
 - `ROW_GROUP_SIZE_BYTES` - default: `32Mb` - maximum size of row group.
 - `ROW_GROUP_SIZE_CHECK_INTERVAL` default: `1000` - number of rows to write before checking if row group size limit is
   reached.
+- `STATISTICS_LEVEL` - default: `StatisticsLevel::PAGE` - `NONE`, `CHUNK` (column chunk statistics) or `PAGE` (also a
+  column index); the offset index is written at every level.
+- `STATISTICS_TRUNCATE_LENGTH` - default: `64` - bytes a string/binary column chunk's min/max statistics are cut to.
 - `VALIDATE_DATA` - default: `true` - if set to `true` then writer will validate data against schema.
 - `WRITER_VERSION` - default `1` - tells writer which version of parquet format should be used.
 
@@ -369,6 +437,89 @@ more frequently.
 Unfortunately, there is no one size fits all solution here.
 You will need to play a bit with those values to find the best one for your use case.
 
+## Statistics
+
+Both engines write the column chunk statistics arrow-rs writes: `min_value`/`max_value` with exactness flags,
+`nan_count` for floats and a column order per leaf.
+
+```php
+<?php
+
+use Flow\Parquet\{Option, Options, Reader, Writer};
+
+(new Writer(options: Options::default()->set(Option::STATISTICS_TRUNCATE_LENGTH, 16)))
+    ->write(__DIR__ . '/orders.parquet', $schema, $rows);
+
+$metadata = (new Reader())->read(__DIR__ . '/orders.parquet')->metadata();
+$column = $metadata->schema()->getFlat('customer');
+
+foreach ($metadata->rowGroups()->all() as $rowGroup) {
+    $statistics = $rowGroup->getColumnChunk($column)->statistics();
+
+    $statistics?->minValue($column);        // physical value: bytes for strings, unscaled int for decimal(10, 2)
+    $statistics?->maxValue($column);
+    $statistics?->isMaxValueExact();        // false when the max was truncated and incremented
+    $statistics?->nullCount();
+    $statistics?->nanCount();               // FLOAT, DOUBLE and FLOAT16 only
+}
+
+$metadata->columnOrder($column);            // ColumnOrder::TypeDefined; ColumnOrder::Absent in files written before it
+```
+
+| Physical type                    | Order of `min_value`/`max_value`                                                       |
+|----------------------------------|----------------------------------------------------------------------------------------|
+| BYTE_ARRAY, FIXED_LEN_BYTE_ARRAY | unsigned bytes (`'10' < '9'`)                                                          |
+| DECIMAL                          | signed (two's complement bytes, or the unscaled INT32/INT64)                           |
+| INT32/INT64 `UINT_*`             | unsigned                                                                               |
+| FLOAT, DOUBLE, FLOAT16           | IEEE 754 total order (`-0.0 < 0.0`); NaN counted, a bound only when every value is NaN |
+| INT96, INTERVAL                  | none: no `min_value`/`max_value` is written                                            |
+
+Strings and binaries longer than `STATISTICS_TRUNCATE_LENGTH` keep a prefix as the min and an incremented prefix as the
+max. Decimals and FLOAT16 are never truncated.
+
+### Page index
+
+Both writers write a column index (each page's min, max, null and NaN counts) and an offset index (where each page
+starts, and its first row) by default. Pages start on row boundaries, lists included.
+
+```php
+<?php
+
+use Flow\Parquet\{Option, Options, Reader, Writer};
+use Flow\Parquet\Writer\StatisticsLevel;
+
+(new Writer(options: Options::default()->set(Option::STATISTICS_LEVEL, StatisticsLevel::CHUNK)))
+    ->write(__DIR__ . '/orders.parquet', $schema, $rows);   // no column index; NONE also drops chunk statistics
+
+$file = (new Reader())->read(__DIR__ . '/orders.parquet');
+$column = $file->schema()->getFlat('customer');
+
+$file->indexes()->columnIndex(0, $column);       // ?ColumnIndex of row group 0: nullPages, minValues, maxValues, ...
+$file->indexes()->offsetIndex(0, $column);       // ?OffsetIndex: pages[i]->offset, compressedPageSize, firstRowIndex
+```
+
+### Bloom filters
+
+A bloom filter per column chunk lets a read skip the row groups that cannot hold a value, where min/max cannot (an id
+inside every group's range). Only `equals()` and `in()` use them. Both writers write them after each row group, for the
+columns asked only.
+
+```php
+<?php
+
+use Flow\Parquet\{Option, Options, Reader, Writer};
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use function Flow\Parquet\DSL\{parquet_column, parquet_query};
+
+(new Writer(options: Options::default()->set(Option::COLUMNS_BLOOM_FILTERS, [
+    'id' => new BloomFilterOptions(),                  // fpp 0.05, ndv 1 048 576 (the arrow-rs defaults)
+    'user.email' => new BloomFilterOptions(0.01, 10_000),
+])))->write(__DIR__ . '/users.parquet', $schema, $rows);
+
+(new Reader())->read(__DIR__ . '/users.parquet')
+    ->values(parquet_query()->select('id')->where(parquet_column('id')->in([42, 1337])));
+```
+
 ## Compressions
 
 > [!NOTE]
diff --git a/documentation/contributing/rust.md b/documentation/contributing/rust.md
index 79c6a7cf77..cdd6bfeac5 100644
--- a/documentation/contributing/rust.md
+++ b/documentation/contributing/rust.md
@@ -169,9 +169,10 @@ holds the same number:
 | flow_php  | `FLOW_PHP_ABI`           | `Flow\ETL\FlowPhpExtension::ABI`          |
 | arrow     | `FLOW_ARROW_ABI`         | `Flow\Parquet\Engine\ArrowExtension::ABI` |
 
-Bump both, in one change, whenever a class or interface the extension registers changes. Every `Adaptive*` pick calls
-`available()`: an extension that is loaded with another ABI, or with none, is refused with a `RuntimeException`
-naming the extension and its version. phpt `099` (flow_php) and `054` (arrow) pin that the two numbers are equal.
+Bump both, in one change, whenever the contract changes: a class or interface the extension registers, or the
+schema, options or values that cross it. Every `Adaptive*` pick calls `available()`: an extension that is loaded with
+another ABI, or with none, is refused with a `RuntimeException` naming the extension and its version. phpt `099`
+(flow_php) and `054` (arrow) pin that the two numbers are equal.
 
 The PHP interfaces an extension also registers are guarded by `interface_exists(X::class, false)`, so an extension
 that does not register one still gets the PHP declaration and fails at the ABI check, not with "Class not found".
diff --git a/documentation/upgrading.md b/documentation/upgrading.md
index 6a715ea207..ccbe728323 100644
--- a/documentation/upgrading.md
+++ b/documentation/upgrading.md
@@ -19,6 +19,117 @@ Upgrading from older versions: [0.35.x to 0.40.x](/documentation/upgrading-0.35-
 | `ListType<list<T>>`, `MapType<array<TKey, TValue>>`                             | `ListType<T>`, `MapType<TKey, TValue>`                                                                |
 | Mago `plugins = ["flow-php"]` infers `type_structure()` shapes                  | Built-in plugin no longer infers them - use `flow-php/mago-types-bridge` (`plugins = ["flow/types"]`) |
 
+### 2) `flow-php/parquet` - statistics are written and read as arrow-rs does; one physical schema for one logical schema on both engines
+
+| Before                                                                                                                                                                 | After                                                                                                                                                                                                    |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| PHP writer string bounds by PHP `<` (`'9'` below `'10'`), whole strings, no exactness flags, no `nan_count`, no `column_orders`, deprecated `min`/`max` for every type | unsigned-byte order, truncated to `Option::STATISTICS_TRUNCATE_LENGTH` (64) bytes, exactness flags, `nan_count` for floats, `column_orders` per leaf, deprecated `min`/`max` only for signed sort orders |
+| statistics of files written by older flow versions read as written                                                                                                     | `ColumnOrder::Absent`: no bounds are trusted, so such files are never pruned; a statistic of the wrong width (older INT64 bounds are 16 bytes) reads as `null`                                           |
+| `StatisticsReader` read BYTE_ARRAY statistics with a length prefix, a FLBA decimal as a float, an INT64 decimal as the unscaled int                                    | raw bytes for BYTE_ARRAY/FLBA (decimals as unscaled two's complement bytes, uuid as 16 bytes), the unscaled int for INT32/INT64 decimals                                                                 |
+| `FlatColumn::decimal()` of precision up to 18 written as FIXED_LEN_BYTE_ARRAY                                                                                          | INT32 up to precision 9, INT64 up to 18, FIXED_LEN_BYTE_ARRAY above; older files still read                                                                                                              |
+| the packer/unpacker encoded FLBA/BYTE_ARRAY decimals and UUIDs; `DecimalConverter` took INT-backed decimals only                                                       | `new DecimalConverter($physicalType, $precision, $scale, $byteLength)` and `UuidConverter` convert to the physical bytes; the packer/unpacker take them as-is                                            |
+| `FlatColumn::int32()` / `int64()` wrote converted `INT_32` / `INT_64`                                                                                                  | plain `INT32` / `INT64`, as arrow-rs                                                                                                                                                                     |
+| a column with a logical type and no converted type written without one (DuckDB read a logical `UINT_64` as signed)                                                     | the converted type derived from the logical type, as arrow-rs; a `FlatColumn` whose converted and logical types disagree is refused, on read and write                                                   |
+| the arrow writer named map entries `m.entries.key`                                                                                                                     | `m.key_value.key` (LogicalTypes.md): `COLUMNS_*` options keyed by `…key_value.key` address the same leaf on both engines                                                                                 |
+| the arrow writer wrote `FlatColumn::enum()` as `STRING`                                                                                                                | `ENUM`                                                                                                                                                                                                   |
+| `Option::ARROW_BATCH_SIZE`, read by nothing                                                                                                                            | removed                                                                                                                                                                                                  |
+| `Flow\Parquet\Dremel\Statistics\Comparator`                                                                                                                            | removed: `Flow\Parquet\Data\PhysicalOrder`                                                                                                                                                               |
+| `new StatisticsCounter($column)`                                                                                                                                       | `new StatisticsCounter($column, new StatisticsTruncation($length))`                                                                                                                                      |
+| `new UnsignedIntegerConverter($path, $bitWidth)`                                                                                                                       | `new UnsignedInt32Converter()`; UINT_64 is `UnsignedInt64Converter`                                                                                                                                      |
+
+### 3) `flow-php/parquet`, `flow-php/etl-adapter-parquet` - `UINT_64` reads as a decimal string on both engines (reverses rows 84 and 85 of 0.44→0.45 for `UINT_64`)
+
+| Before                                                                                  | After                                                                                            |
+|-----------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------|
+| `UINT_64` read as `int`, refused above `PHP_INT_MAX` on both engines                    | read as the decimal string (`'18446744073709551615'`) on both engines; `UINT_8/16/32` stay `int` |
+| `from_parquet()` typed a `UINT_64` column `integer`                                     | `numeric_string`                                                                                 |
+| writes accepted an int from 0 to `PHP_INT_MAX` into `UINT_64`                           | an int >= 0 or a canonical digit string up to `18446744073709551615`                             |
+| `to_parquet()` refused a `numeric_string` column (`NumericStringType is not supported`) | written as a parquet `STRING`                                                                    |
+
+### 4) `flow-php/parquet` - the `arrow` extension must be rebuilt (arrow-rs 60, ABI 2)
+
+| Before                                                  | After                                                                                                                                                      |
+|---------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| arrow-ext built against arrow-rs 59, `FLOW_ARROW_ABI` 1 | arrow-rs 60, `FLOW_ARROW_ABI` / `ArrowExtension::ABI` 2 (covering every contract change below): an older build is refused by `ArrowExtension::available()` |
+
+### 5) `flow-php/parquet`, `flow-php/etl-adapter-parquet` - reads take a `Query` (or, below the file, a `ReadPlan`) instead of limit/offset, the PHP writer writes the page index, the reader exposes its `Footer`; the `arrow` and `flow_php` extensions must be rebuilt
+
+| Before                                                                                                                                                                  | After                                                                                                                                                                                                                                                                         |
+|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ParquetFile::values(array $columns, ?int $limit, ?int $offset)`                                                                                                        | `values(Query $query)`: `$file->values(parquet_query()->select(...$columns)->offset($offset)->limit($limit))`                                                                                                                                                                 |
+| `ParquetFile::columns(int $batchSize, array $columns, ?int $limit, ?int $offset)`                                                                                       | `columns(Query $query, int $batchSize = 1024)`                                                                                                                                                                                                                                |
+| a limit of `0` refused (`Limit must be greater than 0`); a negative offset or limit refused by `columns()`                                                              | `limit(0)` reads no row; a negative offset or limit is refused by `Query`                                                                                                                                                                                                     |
+| `ParquetFileReader::metadata()`, `schema()`, `rowsNumber()`, `totalByteSize()`                                                                                          | `ParquetFileReader::footer(): Footer` holds them (and `rowGroupChunks()`); a footer taken before `close()` stays readable                                                                                                                                                     |
+| `ParquetFileReader::readColumns(array $columns, int $batchSize, ?int $limit, ?int $offset)`                                                                             | `readColumns(array $columns, int $batchSize, ReadPlan $plan)`, returning the rows `$plan->selection` selects that match `$plan->rowFilter`, at most `$plan->limit`; build the plan with `ReadPlanner::plan()` or `ReadPlan::window($rows, $file->indexes(), $offset, $limit)` |
+| `RustParquetFileReader::thrift()`                                                                                                                                       | `RustParquetFileReader::footer()->thrift()` (`RustParquetFooter`)                                                                                                                                                                                                             |
+| `ParquetOpenSource::batches(Schema $schema, int $batchSize, ?int $offset, ?int $limit, Backend $backend)`                                                               | `batches(Schema $schema, int $batchSize, ReadPlan $plan, Backend $backend)`                                                                                                                                                                                                   |
+| `RustBatchReader` / `RustColumnsReader::__construct(..., int $batchSize, ?int $offset, ?int $limit)`                                                                    | `__construct(..., int $batchSize, ReadPlan $plan)`                                                                                                                                                                                                                            |
+| `ColumnReader::read(Column, Metadata, SourceStream, ?int $limit, ?int $offset)`                                                                                         | `readRowGroup(Column, RowGroup, int $group, SourceStream, RowSelection, Indexes, array $decoded = [])`, one row group at a time; `$decoded` pages, keyed by their first row, are served instead of read                                                                       |
+| `new ColumnReader(ColumnChunkReader $chunks, DremelAssembler $assembler)`                                                                                               | `new ColumnReader(new SelectedPages($chunks), $assembler)`                                                                                                                                                                                                                    |
+| `ColumnChunkReader::read(ColumnChunk, FlatColumn, SourceStream)` yielded a list of pages                                                                                | pages keyed by their first row in the row group; `?OffsetIndex $offsetIndex` with `list<int> $pages` reads only those pages of it, `?Dictionary $dictionary` replaces the dictionary page, the generator returns the dictionary                                               |
+| `RowGroupContainer(string, RowGroup)`                                                                                                                                   | `RowGroupContainer(string, RowGroup, list<?ColumnIndex>, list<OffsetIndex>)`                                                                                                                                                                                                  |
+| `new PlainFlatColumnChunkBuilder($column, $options, $compression)` (and the RLE_DICTIONARY, DELTA_BINARY_PACKED builders, `ColumnChunkBuilderFactory::createBuilder()`) | a 4th argument, `StatisticsOptions::fromOptions($options)`                                                                                                                                                                                                                    |
+| `ColumnChunk::dataPageOffset(): ?int`                                                                                                                                   | `int`: a column chunk always records it                                                                                                                                                                                                                                       |
+| the PHP writer wrote no column index or offset index                                                                                                                    | both, by default (`Option::STATISTICS_LEVEL`, `StatisticsLevel::PAGE`; `CHUNK` drops the column index, `NONE` all statistics)                                                                                                                                                 |
+| the PHP writer wrote page-header statistics on `DATA_PAGE_V2`                                                                                                           | none, as arrow-rs: `Option::PAGE_HEADER_STATISTICS` (`true`) writes them, on v1 and v2 pages                                                                                                                                                                                  |
+| `Option::PAGE_MAXIMUM_ROWS_COUNT` (default `1000`) was read by nothing                                                                                                  | the PHP writer closes a page at exactly that many rows; the arrow writer treats it as a target (arrow-rs `data_page_row_count_limit`, checked between write batches), so its pages can hold more; below 1 is refused (`InvalidArgumentException`)                             |
+| the arrow writer skipped a `COLUMNS_COMPRESSIONS` / `COLUMNS_ENCODINGS` entry whose column path is digits only (`'2024'`, an int array key)                             | applies it; a key that is not UTF-8 is refused (`InvalidArgumentException`) instead of crashing the process                                                                                                                                                                   |
+| `Option::ROW_GROUP_SIZE_BYTES` below 1 was taken by both writers                                                                                                        | refused (`InvalidArgumentException`) by both writers                                                                                                                                                                                                                          |
+| the arrow writer threw `Error` (a Rust panic) on `PLAIN_DICTIONARY` / `RLE_DICTIONARY` in `COLUMNS_ENCODINGS`                                                           | enables the column's dictionary: `RLE_DICTIONARY` data pages and a `PLAIN` dictionary page, as the PHP writer writes                                                                                                                                                          |
+| the arrow writer skipped a `COLUMNS_COMPRESSIONS` / `COLUMNS_ENCODINGS` value that is not a string                                                                      | refused (`InvalidArgumentException`)                                                                                                                                                                                                                                          |
+| files with an `RLE_DICTIONARY` column spanning more than one page, written by the PHP writer                                                                            | were corrupt (later pages decoded to wrong values): rewrite them; one dictionary per chunk, `PLAIN` past `Option::DICTIONARY_PAGE_SIZE`                                                                                                                                       |
+| `Option::DICTIONARY_PAGE_MIN_CARDINALITY_RATION`                                                                                                                        | removed: it was never read; the dictionary falls back to `PLAIN` on `Option::DICTIONARY_PAGE_SIZE` only, as arrow-rs                                                                                                                                                          |
+| `Options::set()` / `get()` took scalars and arrays                                                                                                                      | also a `UnitEnum`; `Options::getEnum(Option $option, string $class)`                                                                                                                                                                                                          |
+| no column index truncation option                                                                                                                                       | `Option::COLUMN_INDEX_TRUNCATE_LENGTH` (64): BYTE_ARRAY/FIXED_LEN_BYTE_ARRAY page bounds in the column index                                                                                                                                                                  |
+| `DataPageHeaderV2::statistics(Options $options)`                                                                                                                        | `statistics()`, as `DataPageHeader::statistics()`                                                                                                                                                                                                                             |
+| `ParquetFile::pageHeaders()` repeated every chunk of a row group under each column                                                                                      | each column's own chunk pages, once                                                                                                                                                                                                                                           |
+| `FLOW_PHP_ABI` / `FlowPhpExtension::ABI` 1                                                                                                                              | 2: rebuild the `flow_php` extension (and `arrow`, item 4); an older build is refused by `available()`                                                                                                                                                                         |
+
+### 6) `flow-php/etl`, `flow-php/types` - string comparisons in filters use byte order, as sort already does
+
+| Before                                                                                         | After                                                                                                                                                                |
+|------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ref('a')->lessThan(lit('10'))` on `'9'`: `true` (PHP `<` compares numeric strings as numbers) | `false`: `lessThan`, `lessThanEqual`, `greaterThan`, `greaterThanEqual`, `between`, `greatest` and `least` order two strings by bytes (`strcmp`), as `sortBy()` does |
+| `greatest(lit('9'), lit('10'))`: `'10'`                                                        | `'9'`                                                                                                                                                                |
+| a `numeric_string` column was comparable only with another `numeric_string`                    | comparable with a `string` literal too (`ref('id')->greaterThan(lit('1000'))`), and ordered numerically; still not comparable with an `integer`                      |
+| `Between\Boundary::compareValues(mixed $left, mixed $right)`                                   | removed: `(new ValueOrder(...$operandTypes))->compare($left, $right)`; `Boundary::compare($value, $lower, $upper, ValueOrder $order = new ValueOrder())`             |
+
+### 7) `flow-php/etl` - a file extractor reads a `FileScan` and returns only rows matching its conjuncts; `Read` and `Executor\Pipeline` carry it
+
+| Before                                                                                                       | After                                                                                                                                                                                                                                                                                 |
+|--------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `FileExtractor::extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles())`     | `FileExtractor::scan(FlowContext $context, FileScan $scan)`, returning only rows matching every one of `$scan->conjuncts`; `extract(FlowContext $context, ?int $limit = null)` is `Extractor`'s, `use Scanning;` makes it `scan()` with a limit                                       |
+| `$extractor->extract($context, pathFilter: $filter)`                                                         | `$extractor->scan($context, new FileScan(pathFilter: $filter))`                                                                                                                                                                                                                       |
+| `Read::limit()`, `Read::pathFilter()`, `new Read($extractor, $limit, $pathFilter)`                           | `Read::scan()->limit`, `->pathFilter`, `->conjuncts`; `new Read($extractor, new FileScan($limit, $pathFilter))`                                                                                                                                                                       |
+| `Read::withPathFilter()` on any extractor                                                                    | refused (`InvalidArgumentException`) on an extractor that is no `FileExtractor`, as `withFilter()`                                                                                                                                                                                    |
+| `Executor\Pipeline::limit()`, `pathFilter()`, `new Pipeline(..., $limit, $pathFilter, $sources)`             | `Pipeline::scan()`; `new Pipeline(..., $scan, $sources)`                                                                                                                                                                                                                              |
+| a `filter()` over a file source stayed a `Filter` step                                                       | each deterministic part of it is pushed into the source (`FileScan::$conjuncts`) and leaves the step, an emptied step is removed; a `limit()` after it is pushed beside it, so the read stops after that many matching rows; `explain()` prints each part as `Filter: …` under `Read` |
+| `new FileReadLoop($fileColumns, $schema)`, `read($sources, $batches, $batchSize, Backend $backend, $window)` | `new FileReadLoop($fileColumns, $schema, $scan->conjuncts)`, `read($sources, $batches, $batchSize, FlowContext $context, $window)`                                                                                                                                                    |
+| `Optimizer::default()` ran `PushLimitIntoSource` before `PushFilterIntoSource`                               | after it                                                                                                                                                                                                                                                                              |
+| `Rewrite::of(Node $node)`                                                                                    | `of(Node $original, Node $rebuilt)`: the node as it was and rebuilt over its rewritten children                                                                                                                                                                                       |
+| `new Flow\ETL\Plan\ReplaceLeaf($target, $replacement)`                                                       | `ReplaceNodes::one($target, $replacement)`, or `new ReplaceNodes($replacements, $removals)` for several in one rewrite (a removed node gives way to its child)                                                                                                                        |
+| `new ScalarFunctionFilterTransformer($function, ?ScalarFunction $resolved)`                                  | the second argument is `?Function\Evaluation\Filter`; `bind()` sets it, as before                                                                                                                                                                                                     |
+| `explain()`: `Select` printed `Columns: …`, other nodes `Defines columns: …`                                 | `Keeps only: …` and `Changes columns: …` (a column defined, renamed or dropped)                                                                                                                                                                                                       |
+| `Redefined::$unknown`                                                                                        | `Redefined::isUnknown()`; `Redefined::isAllBut()` tells an `allBut()` apart                                                                                                                                                                                                           |
+
+A custom file extractor:
+
+```php
+// before
+public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+{
+    // reads with $limit and $pathFilter
+}
+
+// after
+use Scanning; // extract() is scan() with only a limit
+
+public function scan(FlowContext $context, FileScan $scan): Generator
+{
+    // reads with $scan->limit and $scan->pathFilter, returns only rows matching every one of $scan->conjuncts
+}
+```
+
 ---
 
 ## Upgrading from 0.45.x to 0.46.x
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
index 29cbc06bf6..9a8fe2f9a8 100644
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@@ -58,6 +58,9 @@
         <testsuite name="lib-parquet-integration">
             <directory>src/lib/parquet/tests/Flow/Parquet/Tests/Integration</directory>
         </testsuite>
+        <testsuite name="lib-parquet-viewer-unit">
+            <directory>src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Unit</directory>
+        </testsuite>
         <testsuite name="lib-parquet-viewer-integration">
             <directory>src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Integration</directory>
         </testsuite>
diff --git a/shell.nix b/shell.nix
index 1118ac4b3e..2c61d28ced 100644
--- a/shell.nix
+++ b/shell.nix
@@ -114,6 +114,7 @@ pkgs.mkShell {
         pkgs.just
         pkgs.oxipng
         pkgs.jpegoptim
+        pkgs.thrift
     ]
         ++ pkgs.lib.optional with-blackfire pkgs.blackfire
         ++ pkgs.lib.optionals with-wasm [
diff --git a/src/adapter/etl-adapter-avro/src/Flow/ETL/Adapter/Avro/FlixTech/AvroExtractor.php b/src/adapter/etl-adapter-avro/src/Flow/ETL/Adapter/Avro/FlixTech/AvroExtractor.php
index 82bd2a81ce..8581487bee 100644
--- a/src/adapter/etl-adapter-avro/src/Flow/ETL/Adapter/Avro/FlixTech/AvroExtractor.php
+++ b/src/adapter/etl-adapter-avro/src/Flow/ETL/Adapter/Avro/FlixTech/AvroExtractor.php
@@ -8,7 +8,10 @@
 use Flow\ETL\Exception\SchemaNotDerivableException;
 use Flow\ETL\Extractor;
 use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\PathFiltering;
+use Flow\ETL\Extractor\File\Scanning;
+use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Extractor\Statistics;
 use Flow\ETL\FlowContext;
 use Flow\ETL\Rows;
@@ -16,12 +19,12 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
 final class AvroExtractor implements Extractor, FileExtractor
 {
+    use Scanning;
+
     private ?Schema $schema = null;
 
     use PathFiltering;
@@ -35,7 +38,10 @@ public function __construct(
         );
     }
 
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    /**
+     * @return Generator<int, Rows, Signal|null, void>
+     */
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         yield Rows::empty(new Schema(), $context->backend());
     }
diff --git a/src/adapter/etl-adapter-csv/src/Flow/ETL/Adapter/CSV/CSVExtractor.php b/src/adapter/etl-adapter-csv/src/Flow/ETL/Adapter/CSV/CSVExtractor.php
index 608d094f26..c65fff7748 100644
--- a/src/adapter/etl-adapter-csv/src/Flow/ETL/Adapter/CSV/CSVExtractor.php
+++ b/src/adapter/etl-adapter-csv/src/Flow/ETL/Adapter/CSV/CSVExtractor.php
@@ -12,10 +12,12 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\InferredColumns;
 use Flow\ETL\Extractor\File\ListedFiles;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\InfersSchema;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
@@ -29,8 +31,6 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Flow\Types\Type\Native\String\StringTypeNarrower;
 use Generator;
 
@@ -47,6 +47,7 @@ final class CSVExtractor implements
 {
     use Batches;
     use FileReading;
+    use Scanning;
 
     private SchemaInference $inference;
 
@@ -97,13 +98,13 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
         $schema = $this->schema();
-        $sources = iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false);
+        $sources = iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false);
 
-        yield from (new FileReadLoop($fileColumns, $schema))->read(
+        yield from (new FileReadLoop($fileColumns, $schema, $scan->conjuncts))->read(
             $sources,
             new CSVFileBatches(
                 new CSVFileReader($this->filesystem, $this->readOptions, $sources),
@@ -117,8 +118,8 @@ public function extract(FlowContext $context, ?int $limit = null, Filter $pathFi
                     : null,
             ),
             $this->batchSize(),
-            $context->backend(),
-            new ReadWindow(limit: $limit),
+            $context,
+            new ReadWindow(limit: $scan->limit),
         );
     }
 
diff --git a/src/adapter/etl-adapter-csv/tests/Flow/ETL/Adapter/CSV/Tests/Integration/CSVExtractorTest.php b/src/adapter/etl-adapter-csv/tests/Flow/ETL/Adapter/CSV/Tests/Integration/CSVExtractorTest.php
index 501557b90d..0eb6bc9d0d 100644
--- a/src/adapter/etl-adapter-csv/tests/Flow/ETL/Adapter/CSV/Tests/Integration/CSVExtractorTest.php
+++ b/src/adapter/etl-adapter-csv/tests/Flow/ETL/Adapter/CSV/Tests/Integration/CSVExtractorTest.php
@@ -13,6 +13,7 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaDefinitionNotUniqueException;
 use Flow\ETL\Exception\SchemaMismatchException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Row\Reference;
 use Flow\ETL\Rows;
@@ -1005,7 +1006,7 @@ public function test_limit(): void
         $extractor = from_csv(path_real(__DIR__ . '/../Fixtures/orders_flow.csv'));
         $extractor->withBatchSize(1);
 
-        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), limit: 2);
+        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), scan: new FileScan(2));
     }
 
     /**
diff --git a/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalKeySetExtractorTest.php b/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalKeySetExtractorTest.php
index 7ae0eed7ba..5c5b0633bb 100644
--- a/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalKeySetExtractorTest.php
+++ b/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalKeySetExtractorTest.php
@@ -15,6 +15,7 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\RuntimeException;
 use Flow\ETL\Exception\SchemaNotDerivableException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Tests\Double\SpyBackend;
 use Flow\ETL\Tests\FlowTestCase;
 use Generator;
@@ -151,7 +152,7 @@ public function test_pushed_limit_issues_no_query_once_satisfied(): void
         );
         $counter->reset();
 
-        self::assertExtractedRowsCount(1500, $extractor, limit: 1500);
+        self::assertExtractedRowsCount(1500, $extractor, scan: new FileScan(1500));
         // the NULL check, 1000, then a page narrowed to the 500 still wanted - and no query for row 1501
         static::assertSame(3, $counter->count);
     }
diff --git a/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalLimitOffsetExtractorTest.php b/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalLimitOffsetExtractorTest.php
index 00746005eb..ac31f5a865 100644
--- a/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalLimitOffsetExtractorTest.php
+++ b/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalLimitOffsetExtractorTest.php
@@ -11,6 +11,7 @@
 use Flow\ETL\Adapter\Doctrine\Tests\Double\NativeHandleStub;
 use Flow\ETL\Cardinality;
 use Flow\ETL\Exception\SchemaNotDerivableException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\Double\SpyBackend;
 use Flow\ETL\Tests\FlowTestCase;
@@ -213,7 +214,7 @@ public function test_pushed_limit_skips_the_count_query(): void
         ))->withBatchSize(2);
         $counter->reset();
 
-        self::assertExtractedRowsCount(5, $extractor, limit: 5);
+        self::assertExtractedRowsCount(5, $extractor, scan: new FileScan(5));
         // the three pages of the unlimited read, without the COUNT(*) in front of them
         static::assertSame(3, $counter->count);
         static::assertStringNotContainsString('COUNT(*)', implode(' ', $counter->queries));
diff --git a/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalQueryExtractorTest.php b/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalQueryExtractorTest.php
index 23f43c874d..6f4d1a1624 100644
--- a/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalQueryExtractorTest.php
+++ b/src/adapter/etl-adapter-doctrine/tests/Flow/ETL/Adapter/Doctrine/Tests/Unit/DbalQueryExtractorTest.php
@@ -12,6 +12,7 @@
 use Flow\ETL\Adapter\Doctrine\Tests\Double\NativeHandleStub;
 use Flow\ETL\Cardinality;
 use Flow\ETL\Exception\SchemaNotDerivableException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\Double\SpyBackend;
 use Flow\ETL\Tests\FlowTestCase;
@@ -131,7 +132,7 @@ public function test_pushed_limit_stops_querying_further_parameter_sets(int $bat
         $counter->reset();
 
         // at 100 the first set is one batch that overshoots the limit - trimming it is the limit operator's job
-        self::assertExtractedRowsCount($extractedRows, $extractor, limit: 5);
+        self::assertExtractedRowsCount($extractedRows, $extractor, scan: new FileScan(5));
         static::assertSame(1, $counter->count);
     }
 
diff --git a/src/adapter/etl-adapter-excel/src/Flow/ETL/Adapter/Excel/ExcelExtractor.php b/src/adapter/etl-adapter-excel/src/Flow/ETL/Adapter/Excel/ExcelExtractor.php
index e079d336de..bae5e9de48 100644
--- a/src/adapter/etl-adapter-excel/src/Flow/ETL/Adapter/Excel/ExcelExtractor.php
+++ b/src/adapter/etl-adapter-excel/src/Flow/ETL/Adapter/Excel/ExcelExtractor.php
@@ -12,10 +12,12 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\InferredColumns;
 use Flow\ETL\Extractor\File\ListedFiles;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\InfersSchema;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
@@ -29,8 +31,6 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 use Throwable;
 
@@ -48,6 +48,7 @@ final class ExcelExtractor implements
 {
     use Batches;
     use FileReading;
+    use Scanning;
 
     private SchemaInference $inference;
 
@@ -121,7 +122,7 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
         $schema = $this->schema();
@@ -141,12 +142,12 @@ public function extract(FlowContext $context, ?int $limit = null, Filter $pathFi
         $this->sampled = null;
 
         try {
-            yield from (new FileReadLoop($fileColumns, $schema))->read(
-                iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false),
+            yield from (new FileReadLoop($fileColumns, $schema, $scan->conjuncts))->read(
+                iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false),
                 $batches,
                 $this->batchSize(),
-                $context->backend(),
-                new ReadWindow(limit: $limit),
+                $context,
+                new ReadWindow(limit: $scan->limit),
             );
         } finally {
             $batches->close();
diff --git a/src/adapter/etl-adapter-excel/tests/Flow/ETL/Adapter/Excel/Tests/Integration/ExcelExtractorTest.php b/src/adapter/etl-adapter-excel/tests/Flow/ETL/Adapter/Excel/Tests/Integration/ExcelExtractorTest.php
index b5190be478..57a8c1db70 100644
--- a/src/adapter/etl-adapter-excel/tests/Flow/ETL/Adapter/Excel/Tests/Integration/ExcelExtractorTest.php
+++ b/src/adapter/etl-adapter-excel/tests/Flow/ETL/Adapter/Excel/Tests/Integration/ExcelExtractorTest.php
@@ -14,6 +14,7 @@
 use Flow\ETL\Exception\InferredSchemaException;
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaMismatchException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\Context\ExtractedRows;
@@ -759,7 +760,7 @@ public function test_limit_reached_on_the_first_file_tail_batch_skips_the_remain
     {
         $extractor = from_excel(ExcelFixtureContext::file('cross_stream/*/*.xlsx'))->withBatchSize(10);
 
-        static::assertCount(2, ExtractedRows::of($extractor, limit: 2));
+        static::assertCount(2, ExtractedRows::of($extractor, scan: new FileScan(2)));
     }
 
     /**
@@ -877,9 +878,9 @@ public function test_a_filtered_extract_infers_over_every_listed_file(): void
         $filtered = from_excel(ExcelFixtureContext::path('sniff/*'));
         $whole = from_excel(ExcelFixtureContext::path('sniff/*'));
 
-        iterator_to_array($filtered->extract(flow_context(), null, new KeepPaths([ExcelFixtureContext::path(
-            'sniff/a',
-        )])), false);
+        iterator_to_array($filtered->scan(flow_context(), new FileScan(pathFilter: new KeepPaths([
+            ExcelFixtureContext::path('sniff/a'),
+        ]))), false);
         $whole->schema();
 
         static::assertEquals($whole->statistics()->rows, $filtered->statistics()->rows);
diff --git a/src/adapter/etl-adapter-json/src/Flow/ETL/Adapter/JSON/JSONMachine/JsonExtractor.php b/src/adapter/etl-adapter-json/src/Flow/ETL/Adapter/JSON/JSONMachine/JsonExtractor.php
index 913e63e3c1..ca88a7caac 100644
--- a/src/adapter/etl-adapter-json/src/Flow/ETL/Adapter/JSON/JSONMachine/JsonExtractor.php
+++ b/src/adapter/etl-adapter-json/src/Flow/ETL/Adapter/JSON/JSONMachine/JsonExtractor.php
@@ -12,9 +12,11 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\ListedFiles;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\InfersSchema;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
@@ -28,8 +30,6 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Flow\Types\Type\Logical\InstanceOfTypeNarrower;
 use Generator;
 
@@ -46,6 +46,7 @@ final class JsonExtractor implements
 {
     use Batches;
     use FileReading;
+    use Scanning;
 
     private SchemaInference $inference;
 
@@ -94,13 +95,13 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
         $schema = $this->schema();
-        $sources = iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false);
+        $sources = iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false);
 
-        yield from (new FileReadLoop($fileColumns, $schema))->read(
+        yield from (new FileReadLoop($fileColumns, $schema, $scan->conjuncts))->read(
             $sources,
             new JsonFileBatches(
                 $this->filesystem,
@@ -115,8 +116,8 @@ public function extract(FlowContext $context, ?int $limit = null, Filter $pathFi
                 $this->pointer,
             ),
             $this->batchSize(),
-            $context->backend(),
-            new ReadWindow(limit: $limit),
+            $context,
+            new ReadWindow(limit: $scan->limit),
         );
     }
 
diff --git a/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonExtractorTest.php b/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonExtractorTest.php
index 2475b04597..21e5a22b8c 100644
--- a/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonExtractorTest.php
+++ b/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonExtractorTest.php
@@ -12,6 +12,7 @@
 use Flow\ETL\Config;
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaMismatchException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Schema\Definition\StringDefinition;
 use Flow\ETL\Tests\Context\ExtractedRows;
@@ -197,7 +198,7 @@ public function test_limit(): void
         $extractor = from_json(path(__DIR__ . '/../../Fixtures/timezones.json'));
         $extractor->withBatchSize(1);
 
-        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), limit: 2);
+        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), scan: new FileScan(2));
     }
 
     public function test_schema_appends_the_metadata_column(): void
diff --git a/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonLinesExtractorTest.php b/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonLinesExtractorTest.php
index 817c815bae..a7d0723814 100644
--- a/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonLinesExtractorTest.php
+++ b/src/adapter/etl-adapter-json/tests/Flow/ETL/Adapter/JSON/Tests/Integration/JSONMachine/JsonLinesExtractorTest.php
@@ -11,6 +11,7 @@
 use Flow\ETL\Config;
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaMismatchException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Schema\Definition\StringDefinition;
 use Flow\ETL\Tests\Context\ExtractedRows;
@@ -189,7 +190,7 @@ public function test_limit(): void
         $extractor = from_json_lines(path(__DIR__ . '/../../Fixtures/timezones.jsonl'));
         $extractor->withBatchSize(1);
 
-        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), limit: 2);
+        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), scan: new FileScan(2));
     }
 
     public function test_schema_appends_the_metadata_column(): void
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/AdaptiveParquetOpenSource.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/AdaptiveParquetOpenSource.php
index 4692df24a8..f2571cdf2a 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/AdaptiveParquetOpenSource.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/AdaptiveParquetOpenSource.php
@@ -9,6 +9,7 @@
 use Flow\ETL\Schema;
 use Flow\Parquet\Engine\RustParquetFileReader;
 use Flow\Parquet\ParquetFile;
+use Flow\Parquet\Reader\ReadPlan;
 use Iterator;
 
 final readonly class AdaptiveParquetOpenSource implements ParquetOpenSource
@@ -25,9 +26,9 @@ public function __construct(ParquetFile $file, ?FlowPhpExtension $extension = nu
             : new PhpParquetOpenSource($file);
     }
 
-    public function batches(Schema $schema, int $batchSize, ?int $offset, ?int $limit, Backend $backend): Iterator
+    public function batches(Schema $schema, int $batchSize, ReadPlan $plan, Backend $backend): Iterator
     {
-        return $this->source->batches($schema, $batchSize, $offset, $limit, $backend);
+        return $this->source->batches($schema, $batchSize, $plan, $backend);
     }
 
     public function close(): void
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetExtractor.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetExtractor.php
index 1f1f374412..e5706a4437 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetExtractor.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetExtractor.php
@@ -12,8 +12,10 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\File\SelfDescribingFile;
 use Flow\ETL\Extractor\File\SourceFile;
 use Flow\ETL\Extractor\RewindableExtractor;
@@ -47,6 +49,7 @@ final class ParquetExtractor implements
 {
     use Batches;
     use FileReading;
+    use Scanning;
 
     private ByteOrder $byteOrder = ByteOrder::LITTLE_ENDIAN;
 
@@ -111,9 +114,9 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
-        $sources = iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false);
+        $sources = iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false);
         // every file is read under the first file's schema, or the union of all of them
         $target = $this->schema();
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
@@ -124,16 +127,18 @@ public function extract(FlowContext $context, ?int $limit = null, Filter $pathFi
             $this->unionByName
                 ? null
                 : new DerivedSchema($this->derivedSchema($this->schemaFiles(), $this->unionByName), $this->derivedFrom),
+            $fileColumns->withoutTail($target),
+            $scan->conjuncts,
         );
         $this->firstFile = null;
 
         try {
-            yield from (new FileReadLoop($fileColumns, $target))->read(
+            yield from (new FileReadLoop($fileColumns, $target, $scan->conjuncts))->read(
                 $sources,
                 $batches,
                 $this->batchSize(),
-                $context->backend(),
-                new ReadWindow($this->offset ?? 0, $limit),
+                $context,
+                new ReadWindow($this->offset ?? 0, $scan->limit),
             );
         } finally {
             $batches->close();
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetFileBatches.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetFileBatches.php
index 204b82b3c4..54e707c23f 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetFileBatches.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetFileBatches.php
@@ -4,6 +4,8 @@
 
 namespace Flow\ETL\Adapter\Parquet;
 
+use Flow\ETL\Adapter\Parquet\Pushdown\FilterTranslator;
+use Flow\ETL\Adapter\Parquet\Pushdown\TranslatedConjunct;
 use Flow\ETL\Column\Backend;
 use Flow\ETL\Exception\InferredSchemaException;
 use Flow\ETL\Extractor\File\DerivedSchema;
@@ -11,26 +13,41 @@
 use Flow\ETL\Extractor\File\OffsetSkippingFileBatches;
 use Flow\ETL\Extractor\File\ReadWindow;
 use Flow\ETL\Extractor\File\SourceFile;
+use Flow\ETL\Function\ScalarFunction;
 use Flow\ETL\Rows;
 use Flow\ETL\Schema;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Reader\ReadPlanner;
 use Generator;
 
 final class ParquetFileBatches implements OffsetSkippingFileBatches
 {
+    /**
+     * @var list<TranslatedConjunct>
+     */
+    private readonly array $conjuncts;
+
     /**
      * @param null|ParquetSourceFile $firstFile the file the schema pass kept open, read instead of opened again
      * @param null|DerivedSchema $derived the schema every file must match; null under unionByName
+     * @param list<ScalarFunction> $conjuncts FileScan::$conjuncts
      */
     public function __construct(
         private readonly ParquetSourceFileOpener $opener,
         private readonly FileColumns $fileColumns,
         private ?ParquetSourceFile $firstFile,
         private readonly ?DerivedSchema $derived,
-    ) {}
+        Schema $body,
+        array $conjuncts = [],
+    ) {
+        $this->conjuncts = (new FilterTranslator())->translate($conjuncts, $body);
+    }
 
     /**
      * Skips the whole file when the window's offset covers it; otherwise reads from the offset. A file of a narrower
-     * schema is matched to $body.
+     * schema is matched to $body. What the conjuncts a file answers exactly prove cannot match is skipped; FileReadLoop
+     * drops the rest that does not match them.
      *
      * @param int<1, max> $batchSize
      *
@@ -57,7 +74,8 @@ public function batches(
         $opened = null;
 
         try {
-            $fileRows = $file->file->reader()->rowsNumber();
+            $footer = $file->file->reader()->footer();
+            $fileRows = $footer->rowsNumber();
 
             if ($window->offset >= $fileRows) {
                 return $fileRows;
@@ -66,9 +84,31 @@ public function batches(
             $this->derived?->refuseDivergence($file->source()->uri(), $file->schema());
 
             $fileBody = $this->fileColumns->withoutTail($file->schema());
+            $kept = [];
+
+            foreach ($this->conjuncts as $conjunct) {
+                if ($conjunct->readsAs($fileBody, $body)) {
+                    $kept[] = $conjunct->filter;
+                }
+            }
+
             $opened = $file->open();
 
-            foreach ($opened->batches($fileBody, $batchSize, $window->offset, $window->limit, $backend) as $rows) {
+            // rows matching the conjuncts the file binds; FileReadLoop drops those the rest do not match
+            foreach ($opened->batches(
+                $fileBody,
+                $batchSize,
+                (new ReadPlanner())->plan(
+                    $footer,
+                    $file->file->indexes(),
+                    $kept === []
+                        ? null
+                        : BoundFilter::bind(new All(...$kept), $footer->schema(), $file->file->options()),
+                    $window->offset,
+                    $window->limit,
+                ),
+                $backend,
+            ) as $rows) {
                 yield $fileBody->isSame($body) ? $rows : $rows->matchTo($body, $backend);
             }
 
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetOpenSource.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetOpenSource.php
index c1cfc09013..bdf3e4314b 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetOpenSource.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetOpenSource.php
@@ -7,6 +7,7 @@
 use Flow\ETL\Column\Backend;
 use Flow\ETL\Rows;
 use Flow\ETL\Schema;
+use Flow\Parquet\Reader\ReadPlan;
 use Iterator;
 
 use function interface_exists;
@@ -20,11 +21,11 @@ interface ParquetOpenSource
     /**
      * Batches of at most $batchSize rows under $schema, every column adopted by $backend.
      *
-     * @param int<1, max> $batchSize
+     * @param int $batchSize refused below 1
      *
      * @return Iterator<int, Rows>
      */
-    public function batches(Schema $schema, int $batchSize, ?int $offset, ?int $limit, Backend $backend): Iterator;
+    public function batches(Schema $schema, int $batchSize, ReadPlan $plan, Backend $backend): Iterator;
 
     public function close(): void;
 }
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetSourceFile.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetSourceFile.php
index 6c9095029b..6ee7f9a20c 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetSourceFile.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/ParquetSourceFile.php
@@ -74,8 +74,8 @@ public function source(): SourceFile
     public function statistics(): Statistics
     {
         return new Statistics(
-            rows: Cardinality::exact($this->file->reader()->rowsNumber()),
-            size: Cardinality::exact($this->file->reader()->totalByteSize()),
+            rows: Cardinality::exact($this->file->reader()->footer()->rowsNumber()),
+            size: Cardinality::exact($this->file->reader()->footer()->totalByteSize()),
         );
     }
 }
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/PhpParquetOpenSource.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/PhpParquetOpenSource.php
index 68eb9383da..dcda6eb973 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/PhpParquetOpenSource.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/PhpParquetOpenSource.php
@@ -10,6 +10,7 @@
 use Flow\ETL\Schema;
 use Flow\ETL\Schema\Definition;
 use Flow\Parquet\ParquetFile;
+use Flow\Parquet\Reader\ReadPlan;
 use Generator;
 
 use function array_map;
@@ -24,13 +25,13 @@ public function __construct(
     /**
      * @return Generator<int, Rows>
      */
-    public function batches(Schema $schema, int $batchSize, ?int $offset, ?int $limit, Backend $backend): Generator
+    public function batches(Schema $schema, int $batchSize, ReadPlan $plan, Backend $backend): Generator
     {
         $names = array_values(array_map(static fn(Definition $definition): string => $definition
             ->entry()
             ->name(), $schema->definitions()));
 
-        foreach ($this->file->columns($batchSize, $names, $limit, $offset) as $chunk) {
+        foreach ($this->file->reader()->readColumns($names, $batchSize, $plan) as $chunk) {
             $builder = new RowsBuilder($schema, $backend);
 
             foreach ($names as $name) {
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/Pushdown/FilterTranslator.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/Pushdown/FilterTranslator.php
new file mode 100644
index 0000000000..d498cb6140
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/Pushdown/FilterTranslator.php
@@ -0,0 +1,355 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Pushdown;
+
+use DateTimeInterface;
+use Flow\ETL\Column\ComparableValues;
+use Flow\ETL\Function\All;
+use Flow\ETL\Function\Any;
+use Flow\ETL\Function\Between;
+use Flow\ETL\Function\Between\Boundary;
+use Flow\ETL\Function\Equals;
+use Flow\ETL\Function\FunctionTree;
+use Flow\ETL\Function\GreaterThan;
+use Flow\ETL\Function\GreaterThanEqual;
+use Flow\ETL\Function\IsIn;
+use Flow\ETL\Function\IsNotNull;
+use Flow\ETL\Function\IsNull;
+use Flow\ETL\Function\LessThan;
+use Flow\ETL\Function\LessThanEqual;
+use Flow\ETL\Function\Literal;
+use Flow\ETL\Function\Not;
+use Flow\ETL\Function\NotEquals;
+use Flow\ETL\Function\NotSame;
+use Flow\ETL\Function\ReferencedColumns;
+use Flow\ETL\Function\Same;
+use Flow\ETL\Function\ScalarFunction;
+use Flow\ETL\Function\StartsWith;
+use Flow\ETL\Row\UnresolvedReference;
+use Flow\ETL\Schema;
+use Flow\ETL\Schema\Definition;
+use Flow\Parquet\Filter\All as ParquetAll;
+use Flow\Parquet\Filter\Any as ParquetAny;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\Operator;
+use Flow\Types\Type;
+use Flow\Types\Type\Logical\DateTimeType;
+use Flow\Types\Type\Logical\DateType;
+use Flow\Types\Type\Logical\JsonType;
+use Flow\Types\Type\Logical\NumericStringType;
+use Flow\Types\Type\Native\FloatType;
+use Flow\Types\Type\Native\IntegerType;
+use Flow\Types\Type\Native\StringType;
+use Flow\Types\Type\TypeDetector;
+use Flow\Types\Value\Uuid;
+
+use function abs;
+use function array_filter;
+use function array_map;
+use function array_values;
+use function ctype_digit;
+use function floor;
+use function Flow\Parquet\DSL\parquet_column;
+use function Flow\Types\DSL\type_bare;
+use function in_array;
+use function is_array;
+use function is_bool;
+use function is_float;
+use function is_int;
+use function is_nan;
+use function is_string;
+
+/**
+ * A conjunct is pushed only when the parquet filter keeps every row the Flow predicate keeps; anything it cannot
+ * prove that for is left to FileReadLoop.
+ */
+final readonly class FilterTranslator
+{
+    /**
+     * @param list<ScalarFunction> $conjuncts
+     *
+     * @return list<TranslatedConjunct> one per translatable conjunct
+     */
+    public function translate(array $conjuncts, Schema $body): array
+    {
+        $translated = [];
+
+        foreach ($conjuncts as $conjunct) {
+            $parquet = $this->filter($conjunct, $body);
+
+            if ($parquet !== null) {
+                $translated[] = new TranslatedConjunct(
+                    $parquet,
+                    array_values((new ReferencedColumns())->in($conjunct)->names()),
+                );
+            }
+        }
+
+        return $translated;
+    }
+
+    private function filter(ScalarFunction $function, Schema $body): ?Filter
+    {
+        $children = $function->children();
+
+        return match (true) {
+            $function instanceof All, $function instanceof Any => $this->combined($function, $body),
+            $function instanceof Not => $children[0] instanceof ScalarFunction
+                ? $this->filter($children[0], $body)?->negate()
+                : null,
+            $function instanceof Equals => $this->comparison($children[0], $children[1], Operator::Equal, $body, false),
+            $function instanceof NotEquals => $this->comparison(
+                $children[0],
+                $children[1],
+                Operator::Equal,
+                $body,
+                false,
+            )?->negate(),
+            $function instanceof Same => $this->comparison($children[0], $children[1], Operator::Equal, $body, true),
+            $function instanceof NotSame => $this->comparison(
+                $children[0],
+                $children[1],
+                Operator::Equal,
+                $body,
+                true,
+            )?->negate(),
+            $function instanceof LessThan => $this->comparison(
+                $children[0],
+                $children[1],
+                Operator::LessThan,
+                $body,
+                false,
+            ),
+            $function instanceof LessThanEqual => $this->comparison(
+                $children[0],
+                $children[1],
+                Operator::LessThanOrEqual,
+                $body,
+                false,
+            ),
+            $function instanceof GreaterThan => $this->comparison(
+                $children[0],
+                $children[1],
+                Operator::GreaterThan,
+                $body,
+                false,
+            ),
+            $function instanceof GreaterThanEqual => $this->comparison(
+                $children[0],
+                $children[1],
+                Operator::GreaterThanOrEqual,
+                $body,
+                false,
+            ),
+            $function instanceof IsNull => $this->isNull($children[0], $body),
+            $function instanceof IsNotNull => $this->isNull($children[0], $body)?->negate(),
+            $function instanceof IsIn => $this->in($children[0], $children[1], $body),
+            $function instanceof StartsWith => $this->startsWith($children[0], $children[1], $body),
+            $function instanceof Between => $this->between($function, $body),
+            default => null,
+        };
+    }
+
+    private function combined(All|Any $function, Schema $body): ?Filter
+    {
+        $filters = [];
+
+        foreach ($function->children() as $child) {
+            $filter = $this->filter($child, $body);
+
+            if ($filter === null) {
+                return null;
+            }
+
+            $filters[] = $filter;
+        }
+
+        return $function instanceof All ? new ParquetAll(...$filters) : new ParquetAny(...$filters);
+    }
+
+    private function comparison(
+        FunctionTree $left,
+        FunctionTree $right,
+        Operator $operator,
+        Schema $body,
+        bool $strict,
+    ): ?Comparison {
+        if ($left instanceof Literal && $right instanceof UnresolvedReference) {
+            return $this->comparison(
+                $right,
+                $left,
+                match ($operator) {
+                    Operator::LessThan => Operator::GreaterThan,
+                    Operator::LessThanOrEqual => Operator::GreaterThanOrEqual,
+                    Operator::GreaterThan => Operator::LessThan,
+                    Operator::GreaterThanOrEqual => Operator::LessThanOrEqual,
+                    Operator::Equal => Operator::Equal,
+                },
+                $body,
+                $strict,
+            );
+        }
+
+        $definition = $this->definition($left, $body);
+
+        if ($definition === null || !$right instanceof Literal) {
+            return null;
+        }
+
+        $value = $this->literal(
+            type_bare($definition->type()),
+            $right->returns(),
+            $right->value(),
+            $operator !== Operator::Equal,
+            $strict,
+        );
+
+        return $value === null ? null : new Comparison(parquet_column($definition->entry()->name()), $operator, $value);
+    }
+
+    private function isNull(FunctionTree $reference, Schema $body): ?Filter
+    {
+        $definition = $this->definition($reference, $body);
+
+        return $definition === null ? null : parquet_column($definition->entry()->name())->isNull();
+    }
+
+    private function in(FunctionTree $haystack, FunctionTree $needle, Schema $body): ?Filter
+    {
+        $definition = $this->definition($needle, $body);
+        // @mago-expect analysis:mixed-assignment
+        $list = $haystack instanceof Literal ? $haystack->value() : null;
+
+        if ($definition === null || !is_array($list)) {
+            return null;
+        }
+
+        // NULL never matches: x IN (1, NULL) keeps what x IN (1) keeps, and NOT (x IN (1, NULL)) is never TRUE
+        $present = array_values(array_filter($list, static fn(mixed $element): bool => $element !== null));
+        $detector = new TypeDetector();
+        $values = array_map(fn(mixed $element): mixed => $this->literal(
+            type_bare($definition->type()),
+            $detector->detectType($element),
+            $element,
+            false,
+            false,
+        ), $present);
+
+        return in_array(null, $values, true) ? null : parquet_column($definition->entry()->name())->in($values);
+    }
+
+    private function startsWith(FunctionTree $haystack, FunctionTree $needle, Schema $body): ?Filter
+    {
+        $definition = $this->definition($haystack, $body);
+        // @mago-expect analysis:mixed-assignment
+        $prefix = $needle instanceof Literal ? $needle->value() : null;
+
+        return $definition !== null && type_bare($definition->type()) instanceof StringType && is_string($prefix)
+            ? parquet_column($definition->entry()->name())->startsWith($prefix)
+            : null;
+    }
+
+    private function between(Between $between, Schema $body): ?Filter
+    {
+        [$value, $lower, $upper, $boundary] = $between->children();
+
+        // @mago-expect analysis:mixed-assignment
+        $kind = $boundary instanceof Literal ? $boundary->value() : null;
+
+        if (!$kind instanceof Boundary) {
+            return null;
+        }
+
+        $lowerBound = $this->comparison(
+            $value,
+            $lower,
+            $kind === Boundary::INCLUSIVE || $kind === Boundary::LEFT_INCLUSIVE
+                ? Operator::GreaterThanOrEqual
+                : Operator::GreaterThan,
+            $body,
+            false,
+        );
+        $upperBound = $this->comparison(
+            $value,
+            $upper,
+            $kind === Boundary::INCLUSIVE || $kind === Boundary::RIGHT_INCLUSIVE
+                ? Operator::LessThanOrEqual
+                : Operator::LessThan,
+            $body,
+            false,
+        );
+
+        return $lowerBound === null || $upperBound === null ? null : $lowerBound->and($upperBound);
+    }
+
+    /**
+     * @return null|Definition<mixed> the body column $function is a reference to, null when it is none
+     */
+    private function definition(FunctionTree $function, Schema $body): ?Definition
+    {
+        return $function instanceof UnresolvedReference ? $body->findDefinition($function->to()) : null;
+    }
+
+    /**
+     * @param Type<mixed> $column
+     * @param Type<mixed> $literal
+     *
+     * @return null|bool|DateTimeInterface|float|int|string the literal as the parquet filter takes it, null when
+     *                                                         the pair cannot be pushed
+     */
+    private function literal(Type $column, Type $literal, mixed $value, bool $ordering, bool $strict): mixed
+    {
+        $literal = type_bare($literal);
+
+        if (is_float($value) && is_nan($value)) {
+            return null;
+        }
+
+        return match (true) {
+            $column instanceof JsonType => null,
+            $column instanceof NumericStringType => !$strict
+                && $literal instanceof StringType
+                && is_string($value)
+                && ctype_digit($value)
+                && ($value === '0' || $value[0] !== '0')
+                    ? $value
+                    : null,
+            !$strict && $column instanceof FloatType && $literal instanceof IntegerType => is_int($value)
+                && abs($value) <= LiteralDomain::EXACT_FLOAT_INTEGER
+                    ? (float) $value
+                    : null,
+            !$strict && $column instanceof IntegerType && $literal instanceof FloatType => is_float($value)
+                && floor($value) === $value
+                && abs($value) < LiteralDomain::EXACT_FLOAT_INTEGER
+                    ? (int) $value
+                    : null,
+            !$strict
+                && (
+                    $column instanceof DateTimeType
+                    && $literal instanceof DateType
+                    || $column instanceof DateType
+                    && $literal instanceof DateTimeType
+                )
+                => $value instanceof DateTimeInterface ? $value : null,
+            $column::class !== $literal::class,
+            !(
+                $ordering
+                    ? (new ComparableValues())->orderedByPhysical($column)
+                    : (new ComparableValues())->equalByPhysical($column)
+            ),
+                => null,
+            $value instanceof Uuid => $value->toString(),
+            is_bool($value),
+            is_int($value),
+            is_float($value),
+            is_string($value),
+            $value instanceof DateTimeInterface,
+                => $value,
+            default => null,
+        };
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/Pushdown/TranslatedConjunct.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/Pushdown/TranslatedConjunct.php
new file mode 100644
index 0000000000..025329e36c
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/Pushdown/TranslatedConjunct.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Pushdown;
+
+use Flow\ETL\Schema;
+use Flow\Parquet\Filter\Filter;
+use Flow\Types\Type\Comparator;
+
+use function Flow\Types\DSL\type_bare;
+
+final readonly class TranslatedConjunct
+{
+    /**
+     * @param list<string> $columns Flow column names the predicate reads
+     */
+    public function __construct(
+        public Filter $filter,
+        public array $columns,
+    ) {}
+
+    /**
+     * True when the file stores every column the predicate reads as $body types it, or not at all. A column the file
+     * stores as another type is cast to the body's, so its statistics are of the other type.
+     */
+    public function readsAs(Schema $fileBody, Schema $body): bool
+    {
+        $comparator = new Comparator();
+
+        foreach ($this->columns as $column) {
+            $stored = $fileBody->findDefinition($column);
+
+            if (
+                $stored !== null
+                && !$comparator->equals(type_bare($stored->type()), type_bare($body->get($column)->type()))
+            ) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/SchemaConverter.php b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/SchemaConverter.php
index 8a31da9663..92e4b4903c 100644
--- a/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/SchemaConverter.php
+++ b/src/adapter/etl-adapter-parquet/src/Flow/ETL/Adapter/Parquet/SchemaConverter.php
@@ -11,6 +11,7 @@
 use Flow\Parquet\ParquetFile\Schema\Column;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Integer;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
 use Flow\Types\Type;
 use Flow\Types\Type\Logical\DateTimeType;
@@ -20,6 +21,7 @@
 use Flow\Types\Type\Logical\JsonType;
 use Flow\Types\Type\Logical\ListType;
 use Flow\Types\Type\Logical\MapType;
+use Flow\Types\Type\Logical\NumericStringType;
 use Flow\Types\Type\Logical\OptionalType;
 use Flow\Types\Type\Logical\StructureElement;
 use Flow\Types\Type\Logical\StructureType;
@@ -38,6 +40,7 @@
 use function Flow\ETL\DSL\bool_schema;
 use function Flow\ETL\DSL\date_schema;
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\json_schema;
@@ -56,6 +59,7 @@
 use function Flow\Types\DSL\type_json;
 use function Flow\Types\DSL\type_list;
 use function Flow\Types\DSL\type_map;
+use function Flow\Types\DSL\type_numeric_string;
 use function Flow\Types\DSL\type_optional;
 use function Flow\Types\DSL\type_string;
 use function Flow\Types\DSL\type_structure;
@@ -118,6 +122,7 @@ private function flowToParquet(string $name, Type $type, bool $nullable): Column
             XMLElementType::class,
             XMLType::class,
             StringType::class,
+            NumericStringType::class,
             NullType::class,
                 => FlatColumn::string($name, $repetition),
             BooleanType::class => FlatColumn::boolean($name, $repetition),
@@ -171,6 +176,10 @@ private function parquetToFlowDefinition(Column $column): Definition
 
             $nullable = $column->repetition() === ParquetSchema\Repetition::OPTIONAL;
 
+            if (Integer::forColumn($column)?->is(64, false) === true) {
+                return definition_from_type($column->name(), type_numeric_string(), $nullable);
+            }
+
             if ($logicalType === null) {
                 return match ($column->type()) {
                     ParquetSchema\PhysicalType::INT32 => match ($column->convertedType()) {
@@ -247,6 +256,10 @@ public function parquetToFlowType(Column $column): Type
 
             $nullable = $column->repetition() === ParquetSchema\Repetition::OPTIONAL;
 
+            if (Integer::forColumn($column)?->is(64, false) === true) {
+                return $nullable ? type_optional(type_numeric_string()) : type_numeric_string();
+            }
+
             if ($logicalType === null) {
                 $type = match ($column->type()) {
                     ParquetSchema\PhysicalType::INT32 => match ($column->convertedType()) {
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/ParquetFilesContext.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/ParquetFilesContext.php
index fc72becdf0..8ad13b9420 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/ParquetFilesContext.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/ParquetFilesContext.php
@@ -5,6 +5,7 @@
 namespace Flow\ETL\Adapter\Parquet\Tests\Context;
 
 use Flow\ETL\Adapter\Parquet\ParquetOpenSink;
+use Flow\ETL\Adapter\Parquet\ParquetSourceFileOpener;
 use Flow\ETL\Adapter\Parquet\RustParquetOpenSink;
 use Flow\ETL\Adapter\Parquet\SchemaConverter;
 use Flow\ETL\Rows;
@@ -20,14 +21,20 @@
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\Column;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\ReadPlanner;
 use Flow\Parquet\Writer;
 
 use function array_count_values;
 use function array_map;
+use function array_sum;
 use function Flow\ETL\Adapter\Parquet\to_parquet;
 use function Flow\ETL\DSL\data_frame;
 use function Flow\ETL\DSL\from_rows;
@@ -37,6 +44,13 @@
 
 final class ParquetFilesContext
 {
+    public static function plan(Filesystem $filesystem, string $uri, int $offset = 0, ?int $limit = null): ReadPlan
+    {
+        $file = (new Reader())->readStream($filesystem->readFrom(path($uri)));
+
+        return (new ReadPlanner())->plan($file->reader()->footer(), $file->indexes(), null, $offset, $limit);
+    }
+
     /**
      * @return array<string>
      */
@@ -149,4 +163,116 @@ public static function opensPerFile(CountingFilesystem $filesystem): array
             ->path()
             ->path(), $filesystem->openedStreams));
     }
+
+    /**
+     * Bytes read through every stream the filesystem opened.
+     */
+    public static function bytesRead(CountingFilesystem $filesystem): int
+    {
+        return array_sum(array_map(
+            static fn(ClosingSpySourceStream $stream): int => $stream->readBytes,
+            $filesystem->openedStreams,
+        ));
+    }
+
+    /**
+     * The chunks of the given columns in the given row groups, by file uri.
+     *
+     * @param array<string, array<string, list<int>>> $groups
+     *
+     * @return list<ColumnChunk>
+     */
+    public static function chunks(Filesystem $filesystem, array $groups): array
+    {
+        $chunks = [];
+
+        foreach ($groups as $uri => $columns) {
+            $file = Reader::php()->readStream($filesystem->readFrom(path($uri)));
+            $rowGroups = $file->metadata()->rowGroups()->all();
+
+            foreach ($columns as $column => $indexes) {
+                foreach ($indexes as $index) {
+                    $chunks[] = $rowGroups[$index]->getColumnChunk($file->schema()->getFlat($column));
+                }
+            }
+        }
+
+        return $chunks;
+    }
+
+    /**
+     * The bytes of the offset indexes of the given columns in the given row groups, by file uri.
+     *
+     * @param array<string, array<string, list<int>>> $groups
+     */
+    public static function offsetIndexBytes(Filesystem $filesystem, array $groups): int
+    {
+        return array_sum(array_map(
+            static fn(ColumnChunk $chunk): int => (int) $chunk->offsetIndex()?->length,
+            self::chunks($filesystem, $groups),
+        ));
+    }
+
+    /**
+     * The bytes of the column and offset indexes of the given columns in the given row groups, by file uri.
+     *
+     * @param array<string, array<string, list<int>>> $groups
+     */
+    public static function pageIndexBytes(Filesystem $filesystem, array $groups): int
+    {
+        return array_sum(array_map(
+            static fn(ColumnChunk $chunk): int => (
+                (int) $chunk->columnIndex()?->length + (int) $chunk->offsetIndex()?->length
+            ),
+            self::chunks($filesystem, $groups),
+        ));
+    }
+
+    /**
+     * A PHP-engine opener of every column under the default options.
+     */
+    public static function opener(Filesystem $filesystem): ParquetSourceFileOpener
+    {
+        return new ParquetSourceFileOpener(
+            $filesystem,
+            new PhpParquetEngine(),
+            Options::default(),
+            new SchemaConverter(),
+            [],
+        );
+    }
+
+    /**
+     * @param iterable<Rows> $batches
+     */
+    public static function rowCount(iterable $batches): int
+    {
+        $count = 0;
+
+        foreach ($batches as $rows) {
+            $count += $rows->count();
+        }
+
+        return $count;
+    }
+
+    /**
+     * A `UINT_64` column `big`, one row group per value.
+     *
+     * @param list<int|string> $values
+     */
+    public static function unsignedInt64(Filesystem $filesystem, string $uri, array $values): void
+    {
+        $options = Options::default()->set(Option::ROW_GROUP_SIZE_BYTES, 1)->set(
+            Option::ROW_GROUP_SIZE_CHECK_INTERVAL,
+            1,
+        );
+        $writer = new Writer(options: $options, engine: new PhpParquetEngine(options: $options));
+        $writer->openForStream(
+            $filesystem->writeTo(path($uri)),
+            Schema::with(new FlatColumn('big', PhysicalType::INT64, logicalType: LogicalType::integer(64, false))),
+        );
+        $writer->writeBatch(array_map(static fn(int|string $value): array => ['big' => $value], $values));
+        $writer->close();
+    }
 }
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/PushdownParityContext.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/PushdownParityContext.php
new file mode 100644
index 0000000000..89c3f9cd1d
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Context/PushdownParityContext.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Tests\Context;
+
+use DateTimeImmutable;
+use Flow\Filesystem\Filesystem;
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Timestamp;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+use Flow\Parquet\Writer;
+
+use function array_map;
+use function Flow\Filesystem\DSL\path;
+use function range;
+use function sprintf;
+
+use const NAN;
+
+final class PushdownParityContext
+{
+    public const array CHUNKS = [
+        'memory://parity/a.parquet' => [
+            'id' => [0, 1, 2],
+            'name' => [0, 1, 2],
+            'score' => [0, 1, 2],
+            'd92' => [0, 1, 2],
+            'd182' => [0, 1, 2],
+            'day' => [0, 1, 2],
+            'ts_us' => [0, 1, 2],
+            'ts_ns' => [0, 1, 2],
+            'uuid' => [0, 1, 2],
+            'extra' => [0, 1, 2],
+        ],
+        'memory://parity/b.parquet' => [
+            'id' => [0],
+            'name' => [0],
+            'score' => [0],
+            'd92' => [0],
+            'd182' => [0],
+            'day' => [0],
+            'ts_us' => [0],
+            'ts_ns' => [0],
+            'uuid' => [0],
+        ],
+    ];
+
+    public const string GLOB = 'memory://parity/*.parquet';
+
+    public static function write(Filesystem $filesystem): void
+    {
+        $options = Options::default()->set(Option::ROW_GROUP_SIZE_BYTES, 1)->set(
+            Option::ROW_GROUP_SIZE_CHECK_INTERVAL,
+            10,
+        );
+        $columns = [
+            FlatColumn::int64('id'),
+            FlatColumn::string('name'),
+            FlatColumn::double('score'),
+            FlatColumn::decimal('d92', 9, 2),
+            FlatColumn::decimal('d182', 18, 2),
+            FlatColumn::date('day'),
+            FlatColumn::dateTime('ts_us'),
+            new FlatColumn(
+                'ts_ns',
+                PhysicalType::INT64,
+                logicalType: new LogicalType(
+                    LogicalType::TIMESTAMP,
+                    timestamp: new Timestamp(true, TimeUnit::NANOSECONDS),
+                ),
+            ),
+            FlatColumn::uuid('uuid'),
+        ];
+        $row = static fn(int $id): array => [
+            'id' => $id,
+            'name' => (string) $id,
+            'score' => $id < 10 ? NAN : $id * 1.5,
+            'd92' => $id + 0.25,
+            'd182' => $id + 0.25,
+            'day' => (new DateTimeImmutable('2024-01-01'))->modify(sprintf('+%d days', $id)),
+            'ts_us' => (new DateTimeImmutable('2024-01-01 00:00:00.123456'))->modify(sprintf('+%d hours', $id)),
+            'ts_ns' => (new DateTimeImmutable('2024-01-01 00:00:00.123456'))->modify(sprintf('+%d hours', $id)),
+            'uuid' => sprintf('00000000-0000-4000-8000-%012d', $id),
+        ];
+
+        foreach ([
+            'a' => [
+                [...$columns, FlatColumn::string('extra')],
+                static fn(int $id): array => [...$row($id), 'extra' => 'x'],
+            ],
+            'b' => [$columns, $row],
+        ] as $file => [$schema, $values]) {
+            $writer = new Writer(options: $options, engine: new PhpParquetEngine(options: $options));
+            $writer->openForStream(
+                $filesystem->writeTo(path(sprintf('memory://parity/%s.parquet', $file))),
+                Schema::with(...$schema),
+            );
+            $writer->writeBatch(array_map($values, $file === 'a' ? range(0, 29) : range(30, 39)));
+            $writer->close();
+        }
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorFooterTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorFooterTest.php
index 8a52068fe0..813011eb62 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorFooterTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorFooterTest.php
@@ -6,6 +6,7 @@
 
 use DateTimeImmutable;
 use Flow\ETL\Adapter\Parquet\Tests\Context\ParquetFilesContext;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Function\Between\Boundary;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\Double\CountingFilesystem;
@@ -113,8 +114,11 @@ public function test_a_path_filter_excluding_the_first_file_closes_the_kept_one(
         $extractor = from_parquet(path(self::PAGINATION . '/*.parquet'), filesystem: $filesystem);
 
         $extractor->schema();
-        $rows = iterator_to_array($extractor->extract(flow_context(), pathFilter: new KeepPaths([path(self::PAGINATION
-        . '/02_500.parquet')])), false);
+        $rows = iterator_to_array(
+            $extractor->scan(flow_context(), new FileScan(pathFilter: new KeepPaths([path(self::PAGINATION
+            . '/02_500.parquet')]))),
+            false,
+        );
 
         static::assertSame(500, array_sum(array_map(static fn(Rows $batch): int => $batch->count(), $rows)));
         static::assertSame(
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorTest.php
index b3735eaeba..d94f898d99 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/ParquetExtractorTest.php
@@ -9,6 +9,7 @@
 use Flow\ETL\Adapter\Parquet\Tests\Context\ParquetFilesContext;
 use Flow\ETL\Cardinality;
 use Flow\ETL\Exception\InferredSchemaException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Plan\Stage;
 use Flow\ETL\Schema\Definition;
@@ -21,6 +22,7 @@
 use Flow\Parquet\Binary\ByteOrder;
 use Flow\Parquet\Engine\PhpParquetEngine;
 use Flow\Parquet\Options;
+use Flow\Parquet\ParquetEngine;
 use Flow\Parquet\Reader;
 use Flow\Types\Value\Json;
 use Flow\Types\Value\Uuid;
@@ -43,9 +45,11 @@
 use function Flow\ETL\DSL\from_sequence_number;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\list_schema;
+use function Flow\ETL\DSL\lit;
 use function Flow\ETL\DSL\map_schema;
 use function Flow\ETL\DSL\partition_by;
 use function Flow\ETL\DSL\partition_types;
+use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
 use function Flow\ETL\DSL\structure_schema;
@@ -64,6 +68,37 @@
 
 final class ParquetExtractorTest extends FlowTestCase
 {
+    /**
+     * @return Generator<string, array{?ParquetEngine}>
+     */
+    public static function engines(): Generator
+    {
+        yield 'default engine' => [null];
+        yield 'php engine' => [new PhpParquetEngine()];
+    }
+
+    #[DataProvider('engines')]
+    public function test_a_body_predicate_skips_row_groups(?ParquetEngine $engine): void
+    {
+        $memory = memory_filesystem();
+        ParquetFilesContext::rowGroups($memory, 'memory://groups.parquet', 3000, 1000);
+        $filtered = new CountingFilesystem($memory);
+        $unfiltered = new CountingFilesystem($memory);
+        $predicate = ref('id')->greaterThanEqual(lit(2500));
+
+        $rows = df()
+            ->read(from_parquet(path('memory://groups.parquet'), filesystem: $filtered, engine: $engine))
+            ->filter($predicate)
+            ->fetch();
+        $all = df()
+            ->read(from_parquet(path('memory://groups.parquet'), filesystem: $unfiltered, engine: $engine))
+            ->fetch();
+
+        static::assertCount(500, $rows);
+        static::assertSame(df()->read(from_rows($all))->filter($predicate)->fetch()->toArray(), $rows->toArray());
+        static::assertLessThan(ParquetFilesContext::bytesRead($unfiltered), ParquetFilesContext::bytesRead($filtered));
+    }
+
     public function test_limit(): void
     {
         $extractor = from_parquet(path(__DIR__ . '/Fixtures/orders_1k.parquet'));
@@ -447,7 +482,10 @@ public function test_a_path_filter_narrows_the_read_but_not_the_schema(): void
         );
         $schema = $extractor->schema();
 
-        $batches = iterator_to_array($extractor->extract(flow_context(config()), pathFilter: new RejectingFilter()));
+        $batches = iterator_to_array($extractor->scan(
+            flow_context(config()),
+            new FileScan(pathFilter: new RejectingFilter()),
+        ));
 
         static::assertSame([], $batches);
         static::assertSame(1, $filesystem->readFromCalls);
@@ -482,7 +520,7 @@ public function test_limit_reached_on_the_first_file_tail_batch_skips_the_remain
     {
         $extractor = from_parquet(path(__DIR__ . '/Fixtures/Pagination/*.parquet'))->withBatchSize(1500);
 
-        static::assertCount(1000, ExtractedRows::of($extractor, limit: 1000));
+        static::assertCount(1000, ExtractedRows::of($extractor, scan: new FileScan(1000)));
     }
 
     public function test_the_second_file_is_asked_for_the_remainder_of_the_limit(): void
@@ -501,7 +539,7 @@ public function test_limit_reached_on_a_full_batch_of_the_first_file_skips_the_r
     {
         $extractor = from_parquet(path(__DIR__ . '/Fixtures/Pagination/*.parquet'))->withBatchSize(500);
 
-        static::assertCount(1000, ExtractedRows::of($extractor, limit: 1000));
+        static::assertCount(1000, ExtractedRows::of($extractor, scan: new FileScan(1000)));
     }
 
     public function test_is_repeatable(): void
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/PushdownParityTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/PushdownParityTest.php
new file mode 100644
index 0000000000..f3d8a46374
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/PushdownParityTest.php
@@ -0,0 +1,160 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Tests\Integration;
+
+use DateTimeImmutable;
+use Flow\ETL\Adapter\Parquet\Tests\Context\ParquetFilesContext;
+use Flow\ETL\Adapter\Parquet\Tests\Context\PushdownParityContext;
+use Flow\ETL\Function\ScalarFunction;
+use Flow\ETL\Optimizer;
+use Flow\ETL\Optimizer\Rule\PushFilterIntoSource;
+use Flow\ETL\Tests\Double\CountingFilesystem;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\ParquetEngine;
+use Flow\Types\Value\Uuid;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+use function Flow\ETL\Adapter\Parquet\from_parquet;
+use function Flow\ETL\DSL\config_builder;
+use function Flow\ETL\DSL\df;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\not;
+use function Flow\ETL\DSL\ref;
+use function Flow\Filesystem\DSL\memory_filesystem;
+use function Flow\Filesystem\DSL\path;
+
+final class PushdownParityTest extends FlowTestCase
+{
+    /**
+     * @return Generator<string, array{?ParquetEngine, ScalarFunction, bool}>
+     */
+    public static function predicates(): Generator
+    {
+        $predicates = [
+            'string range' => [ref('name')->greaterThan(lit('3')), true],
+            'NaN column' => [ref('score')->lessThanEqual(lit(20.0)), true],
+            'decimal(9,2)' => [ref('d92')->greaterThan(lit(15.25)), true],
+            'decimal(18,2)' => [ref('d182')->greaterThan(lit(15.25)), false],
+            'date' => [ref('day')->greaterThanEqual(lit(new DateTimeImmutable('2024-01-21'))), true],
+            'timestamp micros' => [ref('ts_us')->greaterThan(lit(new DateTimeImmutable('2024-01-01 20:30:00'))), true],
+            'timestamp nanos' => [ref('ts_ns')->greaterThan(lit(new DateTimeImmutable('2024-01-01 20:30:00'))), true],
+            'uuid' => [ref('uuid')->equals(lit(new Uuid('00000000-0000-4000-8000-000000000025'))), true],
+            'a negated is in holding null, or an equality' => [
+                not(ref('id')->isIn(lit([1, null])))->or(ref('id')->equals(lit(5))),
+                false,
+            ],
+            'absent column equals' => [ref('extra')->equals(lit('x')), true],
+            'absent column is null' => [ref('extra')->isNull(), true],
+        ];
+
+        foreach (['default engine' => null, 'php engine' => new PhpParquetEngine()] as $engineName => $engine) {
+            foreach ($predicates as $name => [$predicate, $prunes]) {
+                yield $engineName . ', ' . $name => [$engine, $predicate, $prunes];
+            }
+        }
+    }
+
+    /**
+     * @param bool $prunes true when the predicate skips a row group, false when it skips none
+     */
+    #[DataProvider('predicates')]
+    public function test_a_pushed_predicate_returns_what_the_unpushed_one_returns(
+        ?ParquetEngine $engine,
+        ScalarFunction $predicate,
+        bool $prunes,
+    ): void {
+        $memory = memory_filesystem();
+        PushdownParityContext::write($memory);
+        $pushedFilesystem = new CountingFilesystem($memory);
+        $plainFilesystem = new CountingFilesystem($memory);
+
+        $pushed = df()
+            ->read(
+                from_parquet(
+                    path(PushdownParityContext::GLOB),
+                    engine: $engine,
+                    filesystem: $pushedFilesystem,
+                )->unionByName(),
+            )
+            ->filter($predicate)
+            ->fetch();
+        $plain = df(config_builder()->optimizer(Optimizer::default()->without(PushFilterIntoSource::class)))
+            ->read(
+                from_parquet(
+                    path(PushdownParityContext::GLOB),
+                    engine: $engine,
+                    filesystem: $plainFilesystem,
+                )->unionByName(),
+            )
+            ->filter($predicate)
+            ->fetch();
+
+        static::assertNotSame([], $plain->reduceToArray('id'));
+        static::assertSame($plain->reduceToArray('id'), $pushed->reduceToArray('id'));
+        // a pushed read adds at most the page indexes it consults to the chunks it reads
+        static::assertLessThanOrEqual(
+            ParquetFilesContext::bytesRead($plainFilesystem)
+            + ParquetFilesContext::pageIndexBytes($memory, PushdownParityContext::CHUNKS)
+            + ParquetFilesContext::offsetIndexBytes($memory, PushdownParityContext::CHUNKS),
+            ParquetFilesContext::bytesRead($pushedFilesystem),
+        );
+
+        if ($prunes) {
+            static::assertLessThan(
+                ParquetFilesContext::bytesRead($plainFilesystem),
+                ParquetFilesContext::bytesRead($pushedFilesystem),
+            );
+        }
+    }
+
+    /**
+     * @return Generator<string, array{?ParquetEngine}>
+     */
+    public static function engines(): Generator
+    {
+        yield 'default engine' => [null];
+        yield 'php engine' => [new PhpParquetEngine()];
+    }
+
+    #[DataProvider('engines')]
+    public function test_a_limit_beside_a_pushed_filter_reads_fewer_bytes_than_the_unlimited_read(?ParquetEngine $engine): void
+    {
+        $memory = memory_filesystem();
+        PushdownParityContext::write($memory);
+        $limitedFilesystem = new CountingFilesystem($memory);
+        $unlimitedFilesystem = new CountingFilesystem($memory);
+
+        $limited = df()
+            ->read(
+                from_parquet(
+                    path(PushdownParityContext::GLOB),
+                    engine: $engine,
+                    filesystem: $limitedFilesystem,
+                )->unionByName(),
+            )
+            ->filter(ref('id')->lessThan(lit(35)))
+            ->limit(10)
+            ->fetch();
+        $unlimited = df()
+            ->read(
+                from_parquet(
+                    path(PushdownParityContext::GLOB),
+                    engine: $engine,
+                    filesystem: $unlimitedFilesystem,
+                )->unionByName(),
+            )
+            ->filter(ref('id')->lessThan(lit(35)))
+            ->fetch();
+
+        static::assertCount(10, $limited);
+        static::assertCount(35, $unlimited);
+        static::assertLessThan(
+            ParquetFilesContext::bytesRead($unlimitedFilesystem),
+            ParquetFilesContext::bytesRead($limitedFilesystem),
+        );
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/UnsignedInt64ColumnTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/UnsignedInt64ColumnTest.php
new file mode 100644
index 0000000000..f0339e2ccb
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Integration/UnsignedInt64ColumnTest.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Tests\Integration;
+
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Writer;
+
+use function Flow\ETL\Adapter\Parquet\from_parquet;
+use function Flow\ETL\DSL\data_frame;
+use function Flow\Filesystem\DSL\memory_filesystem;
+use function Flow\Filesystem\DSL\path;
+use function Flow\Types\DSL\type_equals;
+use function Flow\Types\DSL\type_numeric_string;
+
+final class UnsignedInt64ColumnTest extends FlowTestCase
+{
+    public function test_a_uint64_column_reads_as_numeric_strings_typed_numeric_string(): void
+    {
+        $memory = memory_filesystem();
+        $path = path('memory://var/uint64.parquet');
+        $writer = new Writer(engine: new PhpParquetEngine());
+        $writer->openForStream(
+            $memory->writeTo($path),
+            Schema::with(new FlatColumn('id', PhysicalType::INT64, logicalType: LogicalType::integer(64, false))),
+        );
+        $writer->writeBatch([['id' => 0], ['id' => '9223372036854775808'], ['id' => '18446744073709551615']]);
+        $writer->close();
+
+        $df = data_frame()->read(from_parquet($path, filesystem: $memory));
+        $rows = $df->fetch();
+
+        static::assertTrue(type_equals(type_numeric_string(), $df->schema()->get('id')->type()));
+        static::assertTrue(type_equals(type_numeric_string(), $rows->schema()->get('id')->type()));
+        static::assertTrue(type_equals(type_numeric_string(), $rows->column('id')->type()));
+        static::assertSame(['0', '9223372036854775808', '18446744073709551615'], $rows->column('id')->values());
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Mother/BodySchemaMother.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Mother/BodySchemaMother.php
new file mode 100644
index 0000000000..d452587c64
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Mother/BodySchemaMother.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Tests\Mother;
+
+use Flow\ETL\Schema;
+
+use function Flow\ETL\DSL\bool_schema;
+use function Flow\ETL\DSL\date_schema;
+use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
+use function Flow\ETL\DSL\float_schema;
+use function Flow\ETL\DSL\int_schema;
+use function Flow\ETL\DSL\json_schema;
+use function Flow\ETL\DSL\schema;
+use function Flow\ETL\DSL\str_schema;
+use function Flow\ETL\DSL\uuid_schema;
+use function Flow\Types\DSL\type_numeric_string;
+
+final class BodySchemaMother
+{
+    /**
+     * One column of every Flow type a parquet leaf reads as.
+     */
+    public static function everyLeafType(): Schema
+    {
+        return schema(
+            int_schema('id', nullable: true),
+            float_schema('price'),
+            str_schema('name'),
+            bool_schema('flag'),
+            uuid_schema('uuid'),
+            json_schema('doc'),
+            datetime_schema('ts'),
+            date_schema('day'),
+            definition_from_type('big', type_numeric_string()),
+        );
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/AdaptiveParquetOpenSourceTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/AdaptiveParquetOpenSourceTest.php
index ce01e23bad..091a722a02 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/AdaptiveParquetOpenSourceTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/AdaptiveParquetOpenSourceTest.php
@@ -13,6 +13,7 @@
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Reader\ReadPlanner;
 use Generator;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
@@ -30,8 +31,7 @@ public function test_a_php_engine_file_reads_through_php(): void
         static::assertInstanceOf(Generator::class, $source->batches(
             schema(int_schema('id')),
             10,
-            null,
-            null,
+            (new ReadPlanner())->plan($file->reader()->footer(), $file->indexes(), null),
             new PhpBackend(),
         ));
         $source->close();
@@ -48,8 +48,7 @@ public function test_with_flow_php_a_rust_engine_file_reads_through_rust(): void
         static::assertInstanceOf(RustIterator::class, $source->batches(
             schema(int_schema('id')),
             10,
-            null,
-            null,
+            (new ReadPlanner())->plan($file->reader()->footer(), $file->indexes(), null),
             new PhpBackend(),
         ));
         $source->close();
@@ -69,8 +68,7 @@ public function test_without_flow_php_a_rust_engine_file_reads_through_php(): vo
         static::assertInstanceOf(Generator::class, $source->batches(
             schema(int_schema('id')),
             10,
-            null,
-            null,
+            (new ReadPlanner())->plan($file->reader()->footer(), $file->indexes(), null),
             new PhpBackend(),
         ));
         $source->close();
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/FlowToParquetSchemaTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/FlowToParquetSchemaTest.php
index 8fce623443..50295d4b68 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/FlowToParquetSchemaTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/FlowToParquetSchemaTest.php
@@ -13,6 +13,7 @@
 
 use function Flow\ETL\DSL\bool_schema;
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\integer_schema;
 use function Flow\ETL\DSL\json_schema;
@@ -26,6 +27,7 @@
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
 use function Flow\Types\DSL\type_map;
+use function Flow\Types\DSL\type_numeric_string;
 use function Flow\Types\DSL\type_string;
 use function Flow\Types\DSL\type_structure;
 
@@ -122,4 +124,12 @@ public function test_converting_nested_structure_with_optional_elements_throws()
             'a' => type_structure(['b' => type_string(), 'c' => structure_element('c', type_string(), optional: true)]),
         ]))));
     }
+
+    public function test_a_numeric_string_column_is_written_as_a_string(): void
+    {
+        static::assertEquals(
+            ParquetSchema::with(FlatColumn::string('id')),
+            (new SchemaConverter())->toParquet(schema(definition_from_type('id', type_numeric_string(), true))),
+        );
+    }
 }
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetFileBatchesTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetFileBatchesTest.php
index 2d91a62f77..cc66637925 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetFileBatchesTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetFileBatchesTest.php
@@ -23,6 +23,8 @@
 use function array_map;
 use function Flow\ETL\DSL\array_to_rows;
 use function Flow\ETL\DSL\int_schema;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
 use function Flow\Filesystem\DSL\memory_filesystem;
@@ -45,7 +47,13 @@ public function test_an_offset_that_covers_the_file_skips_it_and_returns_its_row
             new SchemaConverter(),
             [],
         );
-        $file = (new ParquetFileBatches($opener, FileColumnsContext::discovering(names: []), null, null))->batches(
+        $file = (new ParquetFileBatches(
+            $opener,
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(int_schema('id', nullable: true)),
+        ))->batches(
             new SourceFile(path('memory://a.parquet')),
             schema(int_schema('id', nullable: true)),
             10,
@@ -72,7 +80,13 @@ public function test_an_offset_inside_the_file_starts_the_read_there_and_is_cons
             new SchemaConverter(),
             [],
         );
-        $file = (new ParquetFileBatches($opener, FileColumnsContext::discovering(names: []), null, null))->batches(
+        $file = (new ParquetFileBatches(
+            $opener,
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(int_schema('id', nullable: true)),
+        ))->batches(
             new SourceFile(path('memory://a.parquet')),
             schema(int_schema('id', nullable: true)),
             10,
@@ -108,6 +122,7 @@ public function test_the_kept_first_file_is_read_instead_of_opened_again(): void
             FileColumnsContext::discovering(names: []),
             $kept,
             null,
+            schema(int_schema('id', nullable: true)),
         ))->batches(
             new SourceFile(path('memory://a.parquet')),
             schema(int_schema('id', nullable: true)),
@@ -137,7 +152,13 @@ public function test_a_kept_first_file_of_another_path_is_closed_and_the_file_op
         $kept = $opener->open(new SourceFile(path('memory://a.parquet')));
 
         $rows = iterator_to_array(
-            (new ParquetFileBatches($opener, FileColumnsContext::discovering(names: []), $kept, null))->batches(
+            (new ParquetFileBatches(
+                $opener,
+                FileColumnsContext::discovering(names: []),
+                $kept,
+                null,
+                schema(int_schema('id', nullable: true)),
+            ))->batches(
                 new SourceFile(path('memory://b.parquet')),
                 schema(int_schema('id', nullable: true)),
                 10,
@@ -166,7 +187,13 @@ public function test_close_releases_a_kept_first_file_the_read_never_reached():
         );
         $kept = $opener->open(new SourceFile(path('memory://a.parquet')));
 
-        (new ParquetFileBatches($opener, FileColumnsContext::discovering(names: []), $kept, null))->close();
+        (new ParquetFileBatches(
+            $opener,
+            FileColumnsContext::discovering(names: []),
+            $kept,
+            null,
+            schema(int_schema('id', nullable: true)),
+        ))->close();
 
         static::assertSame($filesystem->readFromCalls, $filesystem->closedStreams());
     }
@@ -191,6 +218,7 @@ public function test_a_file_that_diverges_from_the_derived_schema_is_refused_and
                 FileColumnsContext::discovering(names: []),
                 null,
                 new DerivedSchema(schema(int_schema('id', nullable: true)), 'memory://a.parquet'),
+                schema(int_schema('id')),
             ))->batches(
                 new SourceFile(path('memory://b.parquet')),
                 schema(int_schema('id')),
@@ -203,4 +231,132 @@ public function test_a_file_that_diverges_from_the_derived_schema_is_refused_and
             static::assertSame($filesystem->readFromCalls, $filesystem->closedStreams());
         }
     }
+
+    public function test_a_body_predicate_skips_the_row_groups_it_proves_cannot_match(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 9, 3);
+        $file = (new ParquetFileBatches(
+            ParquetFilesContext::opener($filesystem),
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(int_schema('id', nullable: true), str_schema('name', nullable: true)),
+            [ref('id')->greaterThan(lit(5))],
+        ))->batches(
+            new SourceFile(path('memory://groups.parquet')),
+            schema(int_schema('id', nullable: true), str_schema('name', nullable: true)),
+            10,
+            new PhpBackend(),
+            new ReadWindow(0),
+        );
+
+        static::assertSame(3, ParquetFilesContext::rowCount($file));
+    }
+
+    public function test_the_conjunct_on_a_column_the_file_stores_as_another_type_is_dropped(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::unsignedInt64($filesystem, 'memory://uint64.parquet', ['9', '10', '100']);
+        // the body reads the UINT_64 leaf as a string, ordered by bytes: '10' and '100' are below '2', numerically none is
+        $file = (new ParquetFileBatches(
+            ParquetFilesContext::opener($filesystem),
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(str_schema('big', nullable: true)),
+            [ref('big')->lessThan(lit('2'))],
+        ))->batches(
+            new SourceFile(path('memory://uint64.parquet')),
+            schema(str_schema('big', nullable: true)),
+            10,
+            new PhpBackend(),
+            new ReadWindow(0),
+        );
+
+        static::assertSame(3, ParquetFilesContext::rowCount($file));
+    }
+
+    public function test_equality_on_a_column_absent_from_the_file_reads_no_row(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 9, 3);
+        $file = (new ParquetFileBatches(
+            ParquetFilesContext::opener($filesystem),
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(
+                int_schema('id', nullable: true),
+                str_schema('name', nullable: true),
+                str_schema('missing', nullable: true),
+            ),
+            [ref('missing')->equals(lit('x'))],
+        ))->batches(
+            new SourceFile(path('memory://groups.parquet')),
+            schema(
+                int_schema('id', nullable: true),
+                str_schema('name', nullable: true),
+                str_schema('missing', nullable: true),
+            ),
+            10,
+            new PhpBackend(),
+            new ReadWindow(0),
+        );
+
+        static::assertSame(0, ParquetFilesContext::rowCount($file));
+    }
+
+    public function test_is_null_on_a_column_absent_from_the_file_reads_every_row(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 9, 3);
+        $file = (new ParquetFileBatches(
+            ParquetFilesContext::opener($filesystem),
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(
+                int_schema('id', nullable: true),
+                str_schema('name', nullable: true),
+                str_schema('missing', nullable: true),
+            ),
+            [ref('missing')->isNull()],
+        ))->batches(
+            new SourceFile(path('memory://groups.parquet')),
+            schema(
+                int_schema('id', nullable: true),
+                str_schema('name', nullable: true),
+                str_schema('missing', nullable: true),
+            ),
+            10,
+            new PhpBackend(),
+            new ReadWindow(0),
+        );
+
+        static::assertSame(9, ParquetFilesContext::rowCount($file));
+    }
+
+    public function test_every_group_pruned_still_consumes_the_raw_offset(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 9, 3);
+        $file = (new ParquetFileBatches(
+            ParquetFilesContext::opener($filesystem),
+            FileColumnsContext::discovering(names: []),
+            null,
+            null,
+            schema(int_schema('id', nullable: true), str_schema('name', nullable: true)),
+            [ref('id')->greaterThan(lit(100))],
+        ))->batches(
+            new SourceFile(path('memory://groups.parquet')),
+            schema(int_schema('id', nullable: true), str_schema('name', nullable: true)),
+            10,
+            new PhpBackend(),
+            new ReadWindow(2),
+        );
+
+        static::assertSame(0, ParquetFilesContext::rowCount($file));
+        static::assertSame(2, $file->getReturn());
+    }
 }
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetSourceFileTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetSourceFileTest.php
index 2ffe2c9b15..f1ed6118bf 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetSourceFileTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetSourceFileTest.php
@@ -10,6 +10,7 @@
 use Flow\ETL\Tests\Double\CountingFilesystem;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
+use Flow\Parquet\Reader\ReadPlanner;
 
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\schema;
@@ -32,7 +33,12 @@ public function test_open_reads_the_batches_of_the_file(): void
         $source = $file->open();
         $counts = [];
 
-        foreach ($source->batches(schema(int_schema('id')), 400, 100, 850, new PhpBackend()) as $rows) {
+        foreach ($source->batches(
+            schema(int_schema('id')),
+            400,
+            (new ReadPlanner())->plan($file->file->reader()->footer(), $file->file->indexes(), null, 100, 850),
+            new PhpBackend(),
+        ) as $rows) {
             $counts[] = $rows->count();
         }
 
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetToFlowSchemaTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetToFlowSchemaTest.php
index 51d51ae828..62a9647f2a 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetToFlowSchemaTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/ParquetToFlowSchemaTest.php
@@ -7,11 +7,15 @@
 use Flow\ETL\Adapter\Parquet\SchemaConverter;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\MapKey;
 use Flow\Parquet\ParquetFile\Schema\MapValue;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Schema\Repetition;
 
 use function Flow\ETL\DSL\bool_schema;
 use function Flow\ETL\DSL\date_schema;
@@ -27,9 +31,11 @@
 use function Flow\ETL\DSL\time_schema;
 use function Flow\ETL\DSL\uuid_schema;
 use function Flow\Types\DSL\type_boolean;
+use function Flow\Types\DSL\type_equals;
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
 use function Flow\Types\DSL\type_map;
+use function Flow\Types\DSL\type_numeric_string;
 use function Flow\Types\DSL\type_optional;
 use function Flow\Types\DSL\type_string;
 use function Flow\Types\DSL\type_structure;
@@ -123,4 +129,31 @@ public function test_converting_struct_to_flow_schema(): void
             $flowSchema,
         );
     }
+
+    public function test_uint64_columns_are_numeric_strings(): void
+    {
+        $flowSchema = (new SchemaConverter())->toFlow(Schema::with(
+            new FlatColumn('converted', PhysicalType::INT64, ConvertedType::UINT_64, repetition: Repetition::REQUIRED),
+            new FlatColumn('logical', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            new FlatColumn('uint32', PhysicalType::INT32, ConvertedType::UINT_32),
+        ));
+
+        static::assertTrue(type_equals(type_numeric_string(), $flowSchema->get('converted')->type()));
+        static::assertFalse($flowSchema->get('converted')->isNullable());
+        static::assertTrue(type_equals(type_numeric_string(), $flowSchema->get('logical')->type()));
+        static::assertTrue($flowSchema->get('logical')->isNullable());
+        static::assertTrue(type_equals(type_integer(), $flowSchema->get('uint32')->type()));
+        static::assertTrue(type_equals(
+            type_optional(type_numeric_string()),
+            (new SchemaConverter())->parquetToFlowType(
+                new FlatColumn('u', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            ),
+        ));
+        static::assertTrue(type_equals(
+            type_numeric_string(),
+            (new SchemaConverter())->parquetToFlowType(
+                new FlatColumn('u', PhysicalType::INT64, ConvertedType::UINT_64, repetition: Repetition::REQUIRED),
+            ),
+        ));
+    }
 }
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/PhpParquetOpenSourceTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/PhpParquetOpenSourceTest.php
index 61e9591630..209be0be23 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/PhpParquetOpenSourceTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/PhpParquetOpenSourceTest.php
@@ -9,6 +9,7 @@
 use Flow\ETL\Column\PhpBackend;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Reader;
 use PHPUnit\Framework\Attributes\TestWith;
 
@@ -18,6 +19,7 @@
 use function Flow\ETL\DSL\str_schema;
 use function Flow\Filesystem\DSL\memory_filesystem;
 use function Flow\Filesystem\DSL\path;
+use function iterator_to_array;
 use function range;
 
 final class PhpParquetOpenSourceTest extends FlowTestCase
@@ -25,11 +27,11 @@ final class PhpParquetOpenSourceTest extends FlowTestCase
     /**
      * @param list<int> $ids
      */
-    #[TestWith([null, null, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])]
+    #[TestWith([0, null, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])]
     #[TestWith([3, 5, [3, 4, 5, 6, 7]])]
     #[TestWith([6, null, [6, 7, 8, 9]])]
     #[TestWith([0, 1, [0]])]
-    public function test_offset_and_limit_cross_row_groups(?int $offset, ?int $limit, array $ids): void
+    public function test_a_planned_window_crosses_row_groups(int $offset, ?int $limit, array $ids): void
     {
         $filesystem = memory_filesystem();
         ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 10, 4);
@@ -41,8 +43,7 @@ public function test_offset_and_limit_cross_row_groups(?int $offset, ?int $limit
         ))->readStream($filesystem->readFrom(path('memory://groups.parquet')))))->batches(
             schema(int_schema('id')),
             3,
-            $offset,
-            $limit,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet', $offset, $limit),
             new PhpBackend(),
         ) as $rows) {
             static::assertLessThanOrEqual(3, $rows->count());
@@ -62,7 +63,12 @@ public function test_batches_hold_the_schema_columns(): void
 
         $names = [];
 
-        foreach ($source->batches(schema(str_schema('name')), 100, null, null, new PhpBackend()) as $rows) {
+        foreach ($source->batches(
+            schema(str_schema('name')),
+            100,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet'),
+            new PhpBackend(),
+        ) as $rows) {
             static::assertEquals(schema(str_schema('name')), $rows->schema());
             $names = [...$names, ...$rows->column('name')->values()];
         }
@@ -71,4 +77,40 @@ public function test_batches_hold_the_schema_columns(): void
 
         static::assertSame(array_map(static fn(int $id): string => 'n' . $id, range(0, 9)), $names);
     }
+
+    public function test_a_column_the_file_lacks_is_refused(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 10, 4);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Parquet file has no column "missing"');
+
+        iterator_to_array((new PhpParquetOpenSource((new Reader(
+            engine: new PhpParquetEngine(),
+        ))->readStream($filesystem->readFrom(path('memory://groups.parquet')))))->batches(
+            schema(int_schema('missing')),
+            10,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet'),
+            new PhpBackend(),
+        ));
+    }
+
+    public function test_a_batch_size_below_one_is_refused(): void
+    {
+        $filesystem = memory_filesystem();
+        ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 10, 4);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Parquet batch size must be greater than 0');
+
+        iterator_to_array((new PhpParquetOpenSource((new Reader(
+            engine: new PhpParquetEngine(),
+        ))->readStream($filesystem->readFrom(path('memory://groups.parquet')))))->batches(
+            schema(int_schema('id')),
+            0,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet'),
+            new PhpBackend(),
+        ));
+    }
 }
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/Pushdown/FilterTranslatorTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/Pushdown/FilterTranslatorTest.php
new file mode 100644
index 0000000000..b918586c4f
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/Pushdown/FilterTranslatorTest.php
@@ -0,0 +1,195 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Tests\Unit\Pushdown;
+
+use DateTimeImmutable;
+use Flow\ETL\Adapter\Parquet\Pushdown\FilterTranslator;
+use Flow\ETL\Adapter\Parquet\Pushdown\TranslatedConjunct;
+use Flow\ETL\Adapter\Parquet\Tests\Mother\BodySchemaMother;
+use Flow\ETL\Function\Between\Boundary;
+use Flow\ETL\Function\ScalarFunction;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\Parquet\Filter\Filter;
+use Flow\Types\Value\Uuid;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\not;
+use function Flow\ETL\DSL\ref;
+use function Flow\Parquet\DSL\parquet_column;
+
+use const NAN;
+
+final class FilterTranslatorTest extends FlowTestCase
+{
+    public static function translated(): Generator
+    {
+        yield 'equals' => [ref('id')->equals(lit(5)), parquet_column('id')->equals(5)];
+        yield 'not equals' => [ref('id')->notEquals(lit(5)), parquet_column('id')->notEquals(5)];
+        yield 'less than' => [ref('id')->lessThan(lit(5)), parquet_column('id')->lessThan(5)];
+        yield 'less than or equal' => [ref('id')->lessThanEqual(lit(5)), parquet_column('id')->lessThanOrEqual(5)];
+        yield 'greater than' => [ref('id')->greaterThan(lit(5)), parquet_column('id')->greaterThan(5)];
+        yield 'greater than or equal' => [
+            ref('id')->greaterThanEqual(lit(5)),
+            parquet_column('id')->greaterThanOrEqual(5),
+        ];
+        yield 'a literal on the left is flipped' => [lit(5)->lessThan(ref('id')), parquet_column('id')->greaterThan(5)];
+        yield 'a literal on the left of an equality' => [lit(5)->equals(ref('id')), parquet_column('id')->equals(5)];
+        yield 'same on the same type' => [ref('id')->same(lit(5)), parquet_column('id')->equals(5)];
+        yield 'not same on the same type' => [ref('id')->notSame(lit(5)), parquet_column('id')->notEquals(5)];
+        yield 'is true' => [ref('flag')->isTrue(), parquet_column('flag')->equals(true)];
+        yield 'is null' => [ref('id')->isNull(), parquet_column('id')->isNull()];
+        yield 'is not null' => [ref('id')->isNotNull(), parquet_column('id')->isNotNull()];
+        yield 'not' => [not(ref('id')->equals(lit(5))), parquet_column('id')->equals(5)->negate()];
+        yield 'an or' => [
+            ref('id')->equals(lit(5))->or(ref('name')->equals(lit('a'))),
+            parquet_column('id')->equals(5)->or(parquet_column('name')->equals('a')),
+        ];
+        yield 'an and inside an or' => [
+            ref('id')->equals(lit(5))->or(ref('id')->greaterThan(lit(1))->and(ref('name')->equals(lit('a')))),
+            parquet_column('id')->equals(5)->or(
+                parquet_column('id')->greaterThan(1)->and(parquet_column('name')->equals('a')),
+            ),
+        ];
+        yield 'is in' => [ref('id')->isIn(lit([1, 2])), parquet_column('id')->in([1, 2])];
+        yield 'is in drops null elements' => [ref('id')->isIn(lit([1, null, 2])), parquet_column('id')->in([1, 2])];
+        yield 'a negated is in without null' => [
+            not(ref('id')->isIn(lit([1, 2]))),
+            parquet_column('id')->in([1, 2])->negate(),
+        ];
+        yield 'a negated is in holding null drops the null' => [
+            not(ref('id')->isIn(lit([1, null]))),
+            parquet_column('id')->in([1])->negate(),
+        ];
+        yield 'starts with' => [ref('name')->startsWith(lit('ab')), parquet_column('name')->startsWith('ab')];
+        yield 'between left inclusive' => [
+            ref('id')->between(lit(1), lit(5)),
+            parquet_column('id')->greaterThanOrEqual(1)->and(parquet_column('id')->lessThan(5)),
+        ];
+        yield 'between inclusive' => [
+            ref('id')->between(lit(1), lit(5), lit(Boundary::INCLUSIVE)),
+            parquet_column('id')->greaterThanOrEqual(1)->and(parquet_column('id')->lessThanOrEqual(5)),
+        ];
+        yield 'between right inclusive' => [
+            ref('id')->between(lit(1), lit(5), lit(Boundary::RIGHT_INCLUSIVE)),
+            parquet_column('id')->greaterThan(1)->and(parquet_column('id')->lessThanOrEqual(5)),
+        ];
+        yield 'between exclusive' => [
+            ref('id')->between(lit(1), lit(5), lit(Boundary::EXCLUSIVE)),
+            parquet_column('id')->greaterThan(1)->and(parquet_column('id')->lessThan(5)),
+        ];
+        yield 'an int literal on a float column becomes a float' => [
+            ref('price')->greaterThan(lit(10)),
+            parquet_column('price')->greaterThan(10.0),
+        ];
+        yield 'an int literal on a float column at 2^53' => [
+            ref('price')->equals(lit(9_007_199_254_740_992)),
+            parquet_column('price')->equals(9_007_199_254_740_992.0),
+        ];
+        yield 'an integral float literal on an int column becomes an int' => [
+            ref('id')->lessThan(lit(5.0)),
+            parquet_column('id')->lessThan(5),
+        ];
+        yield 'a float literal on a float column' => [
+            ref('price')->lessThan(lit(1.5)),
+            parquet_column('price')->lessThan(1.5),
+        ];
+        yield 'strings' => [ref('name')->greaterThan(lit('b')), parquet_column('name')->greaterThan('b')];
+        yield 'a canonical digit string on a numeric string column' => [
+            ref('big')->greaterThan(lit('18446744073709551614')),
+            parquet_column('big')->greaterThan('18446744073709551614'),
+        ];
+        yield 'zero on a numeric string column' => [ref('big')->equals(lit('0')), parquet_column('big')->equals('0')];
+        yield 'a uuid literal becomes its string form' => [
+            ref('uuid')->equals(lit(new Uuid('6c2f6e9e-4ec0-4ef7-9b2e-7f2d3f2f6b11'))),
+            parquet_column('uuid')->equals('6c2f6e9e-4ec0-4ef7-9b2e-7f2d3f2f6b11'),
+        ];
+        yield 'a datetime literal passes through' => [
+            ref('ts')->greaterThan(lit(new DateTimeImmutable('2024-01-01 12:00:00'))),
+            parquet_column('ts')->greaterThan(new DateTimeImmutable('2024-01-01 12:00:00')),
+        ];
+        yield 'a date literal passes through' => [
+            ref('day')->lessThan(lit(new DateTimeImmutable('2024-01-01'))),
+            parquet_column('day')->lessThan(new DateTimeImmutable('2024-01-01')),
+        ];
+        yield 'a date literal on a datetime column' => [
+            ref('ts')->greaterThanEqual(lit(new DateTimeImmutable('2024-01-01'))),
+            parquet_column('ts')->greaterThanOrEqual(new DateTimeImmutable('2024-01-01')),
+        ];
+        yield 'a datetime literal on a date column' => [
+            ref('day')->lessThan(lit(new DateTimeImmutable('2024-01-01 12:00:00'))),
+            parquet_column('day')->lessThan(new DateTimeImmutable('2024-01-01 12:00:00')),
+        ];
+        yield 'json is null' => [ref('doc')->isNull(), parquet_column('doc')->isNull()];
+    }
+
+    #[DataProvider('translated')]
+    public function test_a_pushable_conjunct_is_translated(ScalarFunction $function, Filter $expected): void
+    {
+        $translated = (new FilterTranslator())->translate([$function], BodySchemaMother::everyLeafType());
+
+        static::assertCount(1, $translated);
+        static::assertEquals($expected, $translated[0]->filter);
+    }
+
+    public static function refused(): Generator
+    {
+        yield 'a column outside the body' => [ref('year')->equals(lit(2024))];
+        yield 'two references' => [ref('id')->equals(ref('price'))];
+        yield 'two literals' => [lit(1)->equals(lit(1))];
+        yield 'an unsupported function' => [ref('name')->endsWith(lit('a'))];
+        yield 'an unsupported function inside a not' => [not(ref('name')->endsWith(lit('a')))];
+        yield 'an unsupported function inside an or' => [ref('id')->equals(lit(5))->or(ref('name')->endsWith(lit(
+            'a',
+        )))];
+        yield 'is in over a reference haystack' => [ref('id')->isIn(ref('ids'))];
+        yield 'is in with a refused element' => [ref('id')->isIn(lit([1, 'a']))];
+        yield 'starts with on an int column' => [ref('id')->startsWith(lit('1'))];
+        yield 'between with a refused bound' => [ref('id')->between(lit(1), lit('5'))];
+        yield 'same across int and float' => [ref('id')->same(lit(5.0))];
+        yield 'same on a numeric string column' => [ref('big')->same(lit('5'))];
+        yield 'an int literal on a float column above 2^53' => [ref('price')->equals(lit(9_007_199_254_740_993))];
+        yield 'a fractional float literal on an int column' => [ref('id')->lessThan(lit(5.5))];
+        yield 'an integral float literal on an int column at 2^53' => [ref('id')->equals(lit(9_007_199_254_740_992.0))];
+        yield 'a NaN literal' => [ref('price')->equals(lit(NAN))];
+        yield 'an int literal on a string column' => [ref('name')->equals(lit(5))];
+        yield 'a string literal on an int column' => [ref('id')->equals(lit('5'))];
+        yield 'a numeric string column with a leading zero literal' => [ref('big')->equals(lit('05'))];
+        yield 'a numeric string column with a non digit literal' => [ref('big')->equals(lit('-5'))];
+        yield 'a numeric string column with an int literal' => [ref('big')->equals(lit(5))];
+        yield 'ordering on a uuid column' => [
+            ref('uuid')->greaterThan(lit(new Uuid('6c2f6e9e-4ec0-4ef7-9b2e-7f2d3f2f6b11'))),
+        ];
+        yield 'equality on a json column' => [ref('doc')->equals(lit('{}'))];
+        yield 'same across date and datetime' => [ref('day')->same(lit(new DateTimeImmutable('2024-01-01 12:00:00')))];
+    }
+
+    #[DataProvider('refused')]
+    public function test_a_conjunct_that_cannot_be_pushed_is_refused(ScalarFunction $function): void
+    {
+        static::assertSame([], (new FilterTranslator())->translate([$function], BodySchemaMother::everyLeafType()));
+    }
+
+    public function test_every_conjunct_is_translated_on_its_own(): void
+    {
+        $translated = (new FilterTranslator())->translate([
+            ref('id')->greaterThan(lit(1)),
+            ref('name')->endsWith(lit('a')),
+            ref('name')->equals(lit('b'))->or(ref('price')->lessThan(lit(2.0))),
+        ], BodySchemaMother::everyLeafType());
+
+        static::assertEquals(
+            [
+                new TranslatedConjunct(parquet_column('id')->greaterThan(1), ['id']),
+                new TranslatedConjunct(
+                    parquet_column('name')->equals('b')->or(parquet_column('price')->lessThan(2.0)),
+                    ['name', 'price'],
+                ),
+            ],
+            $translated,
+        );
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/Pushdown/TranslatedConjunctTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/Pushdown/TranslatedConjunctTest.php
new file mode 100644
index 0000000000..f740e85ec8
--- /dev/null
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/Pushdown/TranslatedConjunctTest.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Adapter\Parquet\Tests\Unit\Pushdown;
+
+use Flow\ETL\Adapter\Parquet\Pushdown\TranslatedConjunct;
+use Flow\ETL\Tests\FlowTestCase;
+
+use function Flow\ETL\DSL\definition_from_type;
+use function Flow\ETL\DSL\int_schema;
+use function Flow\ETL\DSL\schema;
+use function Flow\ETL\DSL\str_schema;
+use function Flow\Parquet\DSL\parquet_column;
+use function Flow\Types\DSL\type_numeric_string;
+
+final class TranslatedConjunctTest extends FlowTestCase
+{
+    public function test_a_file_storing_every_column_as_the_body_types_it_is_read_as_is(): void
+    {
+        static::assertTrue((new TranslatedConjunct(parquet_column('id')->equals(1), ['id', 'name']))->readsAs(
+            schema(int_schema('id'), str_schema('name')),
+            schema(int_schema('id', nullable: true), str_schema('name', nullable: true)),
+        ));
+    }
+
+    public function test_a_column_the_file_stores_as_another_type_is_not_read_as_is(): void
+    {
+        static::assertFalse((new TranslatedConjunct(parquet_column('big')->lessThan('2'), ['id', 'big']))->readsAs(
+            schema(int_schema('id'), definition_from_type('big', type_numeric_string())),
+            schema(int_schema('id'), str_schema('big')),
+        ));
+    }
+
+    public function test_a_column_absent_from_the_file_is_read_as_is(): void
+    {
+        static::assertTrue((new TranslatedConjunct(parquet_column('missing')->isNull(), ['missing']))->readsAs(
+            schema(int_schema('id')),
+            schema(int_schema('id'), str_schema('missing', nullable: true)),
+        ));
+    }
+}
diff --git a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/RustParquetOpenSourceTest.php b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/RustParquetOpenSourceTest.php
index dd5bfd380a..2293928b33 100644
--- a/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/RustParquetOpenSourceTest.php
+++ b/src/adapter/etl-adapter-parquet/tests/Flow/ETL/Adapter/Parquet/Tests/Unit/RustParquetOpenSourceTest.php
@@ -31,11 +31,11 @@ final class RustParquetOpenSourceTest extends FlowTestCase
     /**
      * @param list<int> $ids
      */
-    #[TestWith([null, null, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])]
+    #[TestWith([0, null, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])]
     #[TestWith([3, 5, [3, 4, 5, 6, 7]])]
     #[TestWith([6, null, [6, 7, 8, 9]])]
     #[TestWith([0, 1, [0]])]
-    public function test_offset_and_limit_cross_row_groups(?int $offset, ?int $limit, array $ids): void
+    public function test_a_planned_window_crosses_row_groups(int $offset, ?int $limit, array $ids): void
     {
         $filesystem = memory_filesystem();
         ParquetFilesContext::rowGroups($filesystem, 'memory://groups.parquet', 10, 4);
@@ -44,7 +44,12 @@ public function test_offset_and_limit_cross_row_groups(?int $offset, ?int $limit
 
         foreach ((new RustParquetOpenSource(new RustParquetFileReader($filesystem->readFrom(path(
             'memory://groups.parquet',
-        )))))->batches(schema(int_schema('id')), 3, $offset, $limit, new AdaptiveBackend()) as $rows) {
+        )))))->batches(
+            schema(int_schema('id')),
+            3,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet', $offset, $limit),
+            new AdaptiveBackend(),
+        ) as $rows) {
             static::assertLessThanOrEqual(3, $rows->count());
             $read = [...$read, ...$rows->column('id')->values()];
         }
@@ -62,7 +67,12 @@ public function test_columns_are_adopted_by_the_backend(): void
 
         $names = [];
 
-        foreach ($source->batches(schema(str_schema('name')), 100, null, null, new PhpBackend()) as $rows) {
+        foreach ($source->batches(
+            schema(str_schema('name')),
+            100,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet'),
+            new PhpBackend(),
+        ) as $rows) {
             static::assertEquals(schema(str_schema('name')), $rows->schema());
             static::assertInstanceOf(ScalarColumn::class, $rows->column('name'));
             $names = [...$names, ...$rows->column('name')->values()];
@@ -80,13 +90,23 @@ public function test_a_second_batches_call_closes_the_first_reader(): void
         $source = new RustParquetOpenSource(new RustParquetFileReader($filesystem->readFrom(path(
             'memory://groups.parquet',
         ))));
-        $first = $source->batches(schema(int_schema('id')), 3, null, null, new AdaptiveBackend());
+        $first = $source->batches(
+            schema(int_schema('id')),
+            3,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet'),
+            new AdaptiveBackend(),
+        );
         $first->rewind();
         static::assertSame([0, 1, 2], $first->current()->column('id')->values());
 
         $second = [];
 
-        foreach ($source->batches(schema(int_schema('id')), 3, null, null, new AdaptiveBackend()) as $rows) {
+        foreach ($source->batches(
+            schema(int_schema('id')),
+            3,
+            ParquetFilesContext::plan($filesystem, 'memory://groups.parquet'),
+            new AdaptiveBackend(),
+        ) as $rows) {
             $second = [...$second, ...$rows->column('id')->values()];
         }
 
diff --git a/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlCursorExtractorTest.php b/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlCursorExtractorTest.php
index b1f9eb39c7..36c4df399e 100644
--- a/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlCursorExtractorTest.php
+++ b/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlCursorExtractorTest.php
@@ -11,6 +11,7 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaMismatchException;
 use Flow\ETL\Exception\SchemaNotDerivableException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Tests\Double\SpyBackend;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\PostgreSql\AST\Transformers\ExplainConfig;
@@ -322,7 +323,7 @@ public function test_pushed_limit_issues_no_query_once_satisfied(): void
             );
         $extractor = from_pgsql_cursor($client, 'SELECT id FROM t');
 
-        self::assertExtractedRowsCount(1500, $extractor, limit: 1500);
+        self::assertExtractedRowsCount(1500, $extractor, scan: new FileScan(1500));
         // FETCH 1000, then FETCH 500 - a full narrowed fetch, which only the limit itself can stop
         static::assertSame(2, $client->callsTo('cursor'));
     }
diff --git a/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlKeySetExtractorTest.php b/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlKeySetExtractorTest.php
index 598840c54b..511bcf23e1 100644
--- a/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlKeySetExtractorTest.php
+++ b/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlKeySetExtractorTest.php
@@ -14,6 +14,7 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\RuntimeException;
 use Flow\ETL\Exception\SchemaNotDerivableException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Tests\Double\SpyBackend;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\PostgreSql\AST\Transformers\ExplainConfig;
@@ -387,7 +388,7 @@ public function test_pushed_limit_issues_no_query_once_satisfied(): void
             pgsql_pagination_key_set(pgsql_pagination_key_asc('id')),
         );
 
-        self::assertExtractedRowsCount(1500, $extractor, limit: 1500);
+        self::assertExtractedRowsCount(1500, $extractor, scan: new FileScan(1500));
         // 1000, then a page narrowed to the 500 still wanted - and no third query for row 1501
         static::assertSame(2, $client->callsTo('cursor'));
     }
diff --git a/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlLimitOffsetExtractorTest.php b/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlLimitOffsetExtractorTest.php
index 17b3e1d473..e38cf78f8b 100644
--- a/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlLimitOffsetExtractorTest.php
+++ b/src/adapter/etl-adapter-postgresql/tests/Flow/ETL/Adapter/PostgreSql/Tests/Unit/PostgreSqlLimitOffsetExtractorTest.php
@@ -10,6 +10,7 @@
 use Flow\ETL\Cardinality;
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaNotDerivableException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\Double\SpyBackend;
 use Flow\ETL\Tests\FlowTestCase;
@@ -303,7 +304,7 @@ public function test_pushed_limit_skips_the_count_query(): void
             ->willReturnCursors(new StubCursor([['id' => '1'], ['id' => '2']]), new StubCursor([['id' => '3']]));
         $extractor = from_pgsql_limit_offset($client, 'SELECT id FROM t ORDER BY id')->withBatchSize(2);
 
-        self::assertExtractedRowsCount(3, $extractor, limit: 3);
+        self::assertExtractedRowsCount(3, $extractor, scan: new FileScan(3));
         // the count query is the only caller of fetchScalarInt()
         static::assertSame(0, $client->callsTo('fetchScalarInt'));
     }
diff --git a/src/adapter/etl-adapter-text/src/Flow/ETL/Adapter/Text/TextExtractor.php b/src/adapter/etl-adapter-text/src/Flow/ETL/Adapter/Text/TextExtractor.php
index 6bbb6fbcba..c404495d37 100644
--- a/src/adapter/etl-adapter-text/src/Flow/ETL/Adapter/Text/TextExtractor.php
+++ b/src/adapter/etl-adapter-text/src/Flow/ETL/Adapter/Text/TextExtractor.php
@@ -11,9 +11,11 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\ListedFiles;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Extractor\Statistics;
@@ -23,8 +25,6 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
 use function Flow\ETL\DSL\schema;
@@ -40,6 +40,8 @@ final class TextExtractor implements
     MetadataColumnsExtractor,
     RewindableExtractor
 {
+    use Scanning;
+
     private ?Schema $schema = null;
 
     use Batches;
@@ -74,19 +76,20 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
 
         yield from (new FileReadLoop(
             $fileColumns,
             $fileColumns->declare($this->schema ?? schema(str_schema('text'))),
+            $scan->conjuncts,
         ))->read(
-            iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false),
+            iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false),
             new TextFileBatches($this->filesystem),
             $this->batchSize(),
-            $context->backend(),
-            new ReadWindow(limit: $limit),
+            $context,
+            new ReadWindow(limit: $scan->limit),
         );
     }
 
diff --git a/src/adapter/etl-adapter-text/tests/Flow/ETL/Adapter/Text/Tests/Integration/TextExtractorTest.php b/src/adapter/etl-adapter-text/tests/Flow/ETL/Adapter/Text/Tests/Integration/TextExtractorTest.php
index 66513a4c61..c8c7f26f4a 100644
--- a/src/adapter/etl-adapter-text/tests/Flow/ETL/Adapter/Text/Tests/Integration/TextExtractorTest.php
+++ b/src/adapter/etl-adapter-text/tests/Flow/ETL/Adapter/Text/Tests/Integration/TextExtractorTest.php
@@ -8,6 +8,7 @@
 use Flow\ETL\Adapter\Text\TextExtractor;
 use Flow\ETL\Cardinality;
 use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Tests\Context\ExtractedRows;
 use Flow\ETL\Tests\Context\MemoryFiles;
@@ -56,7 +57,7 @@ public function test_limit(): void
         $extractor = from_text(path_real(__DIR__ . '/../Fixtures/orders_flow.csv'));
         $extractor->withBatchSize(1);
 
-        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), limit: 2);
+        self::assertExtractedRowsCount(2, $extractor, flow_context(config()), scan: new FileScan(2));
     }
 
     public function test_partition_columns_are_not_leaking_between_streams(): void
@@ -116,7 +117,7 @@ public function test_limit_reached_on_the_first_file_tail_batch_skips_the_remain
     {
         $extractor = from_text(__DIR__ . '/../Fixtures/cross_stream/*/data.txt')->withBatchSize(10);
 
-        static::assertCount(1, ExtractedRows::of($extractor, limit: 1));
+        static::assertCount(1, ExtractedRows::of($extractor, scan: new FileScan(1)));
     }
 
     public function test_metadata_columns_extend_a_declared_schema(): void
diff --git a/src/adapter/etl-adapter-xml/src/Flow/ETL/Adapter/XML/XMLParserExtractor.php b/src/adapter/etl-adapter-xml/src/Flow/ETL/Adapter/XML/XMLParserExtractor.php
index 08ac7ea654..36eb7d0254 100644
--- a/src/adapter/etl-adapter-xml/src/Flow/ETL/Adapter/XML/XMLParserExtractor.php
+++ b/src/adapter/etl-adapter-xml/src/Flow/ETL/Adapter/XML/XMLParserExtractor.php
@@ -11,9 +11,11 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\ListedFiles;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Extractor\Statistics;
@@ -23,8 +25,6 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
 use function Flow\ETL\DSL\schema;
@@ -42,6 +42,7 @@ final class XMLParserExtractor implements
 {
     use Batches;
     use FileReading;
+    use Scanning;
 
     /**
      * @var int<1, max>
@@ -96,19 +97,20 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
 
         yield from (new FileReadLoop(
             $fileColumns,
             $fileColumns->declare($this->schema ?? schema(xml_schema('node'))),
+            $scan->conjuncts,
         ))->read(
-            iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false),
+            iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false),
             new XMLFileBatches($this->filesystem, $this->xmlNodePath, $this->bufferSize),
             $this->batchSize(),
-            $context->backend(),
-            new ReadWindow(limit: $limit),
+            $context,
+            new ReadWindow(limit: $scan->limit),
         );
     }
 
diff --git a/src/adapter/etl-adapter-xml/tests/Flow/ETL/Adapter/XML/Tests/Integration/XMLParserExtractorTest.php b/src/adapter/etl-adapter-xml/tests/Flow/ETL/Adapter/XML/Tests/Integration/XMLParserExtractorTest.php
index f61c618cf1..70dbfd67ba 100644
--- a/src/adapter/etl-adapter-xml/tests/Flow/ETL/Adapter/XML/Tests/Integration/XMLParserExtractorTest.php
+++ b/src/adapter/etl-adapter-xml/tests/Flow/ETL/Adapter/XML/Tests/Integration/XMLParserExtractorTest.php
@@ -11,6 +11,7 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\RuntimeException;
 use Flow\ETL\Exception\SchemaMismatchException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Tests\Context\ExtractedRows;
 use Flow\ETL\Tests\Context\MemoryFiles;
@@ -386,7 +387,7 @@ public function test_limit_reached_on_the_first_file_tail_batch_skips_the_remain
     {
         $extractor = from_xml(__DIR__ . '/../Fixtures/cross_stream/*/file.xml', 'root/item')->withBatchSize(10);
 
-        static::assertCount(1, ExtractedRows::of($extractor, limit: 1));
+        static::assertCount(1, ExtractedRows::of($extractor, scan: new FileScan(1)));
     }
 
     public function test_is_repeatable(): void
diff --git a/src/core/etl/src/Flow/ETL/Column/Physical/PhysicalFor.php b/src/core/etl/src/Flow/ETL/Column/Physical/PhysicalFor.php
index ccd58a6b90..600f942940 100644
--- a/src/core/etl/src/Flow/ETL/Column/Physical/PhysicalFor.php
+++ b/src/core/etl/src/Flow/ETL/Column/Physical/PhysicalFor.php
@@ -120,7 +120,6 @@ public function supports(Type $type): bool
             $base instanceof EmptyArrayType,
             $base instanceof PositiveIntegerType,
             $base instanceof NonEmptyStringType,
-            $base instanceof NumericStringType,
             $base instanceof ClassStringType,
                 => false,
             default => $this->supportsChild($base),
diff --git a/src/core/etl/src/Flow/ETL/DSL/functions.php b/src/core/etl/src/Flow/ETL/DSL/functions.php
index 6212068b75..18326aeee3 100644
--- a/src/core/etl/src/Flow/ETL/DSL/functions.php
+++ b/src/core/etl/src/Flow/ETL/DSL/functions.php
@@ -226,6 +226,7 @@
 use Flow\Types\Type\Logical\JsonType;
 use Flow\Types\Type\Logical\ListType;
 use Flow\Types\Type\Logical\MapType;
+use Flow\Types\Type\Logical\NumericStringType;
 use Flow\Types\Type\Logical\OptionalType;
 use Flow\Types\Type\Logical\StructureType;
 use Flow\Types\Type\Logical\TimeType;
@@ -1620,6 +1621,7 @@ function definition_from_type(
         $type instanceof IntegerType => new IntegerDefinition($ref, $nullable, $metadata),
         $type instanceof FloatType => new FloatDefinition($ref, $nullable, $metadata),
         $type instanceof StringType => new StringDefinition($ref, $nullable, $metadata),
+        $type instanceof NumericStringType => new StringDefinition($ref, $nullable, $metadata, $type),
         $type instanceof DateType => new DateDefinition($ref, $nullable, $metadata),
         $type instanceof DateTimeType => new DateTimeDefinition($ref, $type, $nullable, $metadata),
         $type instanceof TimeType => new TimeDefinition($ref, $nullable, $metadata),
diff --git a/src/core/etl/src/Flow/ETL/Executor.php b/src/core/etl/src/Flow/ETL/Executor.php
index 60b6e75af9..2a2988812b 100644
--- a/src/core/etl/src/Flow/ETL/Executor.php
+++ b/src/core/etl/src/Flow/ETL/Executor.php
@@ -10,7 +10,6 @@
 use Flow\ETL\Executor\PhysicalPlan;
 use Flow\ETL\Executor\Pipeline;
 use Flow\ETL\Extractor\File\FileExtractor;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 use Throwable;
 use WeakMap;
@@ -142,19 +141,16 @@ public function executePipeline(Pipeline $pipeline): Generator
             'pipeline #%d',
             $leaf->id,
         ));
+        $scan = $leaf->scan();
         $generator = (new AdoptedBatches($leaf->context()->backend()))->of(
             $source instanceof FileExtractor
-                ? $source->extract($leaf->context(), $leaf->limit(), $leaf->pathFilter())
-                : $source->extract($leaf->context(), $leaf->limit()),
+                ? $source->scan($leaf->context(), $scan)
+                : $source->extract($leaf->context(), $scan->limit),
         );
         $sources = $leaf->sources();
 
         if ($sources !== null) {
-            $generator = $sources->count(
-                $source,
-                $generator,
-                $leaf->limit() !== null || !$leaf->pathFilter() instanceof OnlyFiles,
-            );
+            $generator = $sources->count($source, $generator, $scan->narrows());
         }
 
         foreach ($chain as $stage) {
diff --git a/src/core/etl/src/Flow/ETL/Executor/Pipeline.php b/src/core/etl/src/Flow/ETL/Executor/Pipeline.php
index 534927d41b..f5b5bce309 100644
--- a/src/core/etl/src/Flow/ETL/Executor/Pipeline.php
+++ b/src/core/etl/src/Flow/ETL/Executor/Pipeline.php
@@ -4,9 +4,8 @@
 
 namespace Flow\ETL\Executor;
 
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\FlowContext;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 
 final readonly class Pipeline
 {
@@ -18,10 +17,8 @@
      * @param FlowContext $context the frame this pipeline was planned in
      * @param null|self $input the pipeline whose output is this one's rows; null when this pipeline
      *                         reads the extractor in $segments
-     * @param null|int<1, max> $limit handed to the source extractor when this pipeline reads it; meaningless
-     *                                behind an input edge
-     * @param Filter $pathFilter handed to a FileExtractor source when this pipeline reads it; meaningless
-     *                           behind an input edge
+     * @param FileScan $scan handed to a FileExtractor source (only its limit to any other source) when this
+     *                       pipeline reads it; meaningless behind an input edge
      * @param null|SourceRows $sources counts the rows of the source when this pipeline reads it and the run is
      *                                 analyzed with source statistics; null otherwise
      */
@@ -30,8 +27,7 @@ public function __construct(
         private Segments $segments,
         private FlowContext $context,
         private ?self $input = null,
-        private ?int $limit = null,
-        private Filter $pathFilter = new OnlyFiles(),
+        private FileScan $scan = new FileScan(),
         private ?SourceRows $sources = null,
     ) {}
 
@@ -45,17 +41,9 @@ public function context(): FlowContext
         return $this->context;
     }
 
-    /**
-     * @return null|int<1, max>
-     */
-    public function limit(): ?int
-    {
-        return $this->limit;
-    }
-
-    public function pathFilter(): Filter
+    public function scan(): FileScan
     {
-        return $this->pathFilter;
+        return $this->scan;
     }
 
     public function sources(): ?SourceRows
diff --git a/src/core/etl/src/Flow/ETL/Executor/SourceRead.php b/src/core/etl/src/Flow/ETL/Executor/SourceRead.php
index 602a908493..ea2572bb3a 100644
--- a/src/core/etl/src/Flow/ETL/Executor/SourceRead.php
+++ b/src/core/etl/src/Flow/ETL/Executor/SourceRead.php
@@ -34,7 +34,7 @@ public function rows(): int
     }
 
     /**
-     * Every read ran to its end and none had a limit or a partition filter pushed into it.
+     * Every read ran to its end and none had a limit, a partition filter or a predicate pushed into it.
      */
     public function isComplete(): bool
     {
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/FileBatches.php b/src/core/etl/src/Flow/ETL/Extractor/File/FileBatches.php
index 6e33736842..fb793345c3 100644
--- a/src/core/etl/src/Flow/ETL/Extractor/File/FileBatches.php
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/FileBatches.php
@@ -18,7 +18,9 @@ interface FileBatches
      * The return value is the rows of the window's offset this file consumed. A format that cannot skip rows is given
      * offset 0 and a limit that counts the offset still to skip, and returns 0: FileReadLoop slices the offset from its
      * rows. An OffsetSkippingFileBatches is given the offset and returns the rows it skipped. The limit is a hint a
-     * format may exceed - FileReadLoop trims what goes past it.
+     * format may exceed - FileReadLoop trims what goes past it - and null when the read carries conjuncts, whose rows
+     * FileReadLoop counts. FileReadLoop applies the conjuncts to every row returned; a format given them when built may
+     * skip what they prove cannot match.
      *
      * A file's own resources are released by the generator (finally). Resources that span files - a kept first file,
      * an inference sample - belong to the per-read object; the extractor that built it calls its close() in a finally
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/FileExtractor.php b/src/core/etl/src/Flow/ETL/Extractor/File/FileExtractor.php
index f8b5369cc0..f874f6b49c 100644
--- a/src/core/etl/src/Flow/ETL/Extractor/File/FileExtractor.php
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/FileExtractor.php
@@ -10,8 +10,6 @@
 use Flow\ETL\Rows;
 use Flow\ETL\Schema;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
 /**
@@ -21,13 +19,13 @@
 interface FileExtractor extends Extractor
 {
     /**
-     * @param null|int<1, max> $limit see Extractor::extract()
-     * @param Filter $pathFilter what this read lists. The Filter step stays in the plan, so a source that lists
-     *                           more, or ignores it, is still correct.
+     * Reads what the plan pushed into this read and returns only rows matching every one of $scan->conjuncts. The
+     * limit and the path filter are hints: the plan still enforces the limit, and every path filter is also one of
+     * the conjuncts, so a source that reads or lists more is still correct. extract() is scan() with only a limit.
      *
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator;
+    public function scan(FlowContext $context, FileScan $scan): Generator;
 
     public function source(): Path;
 
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/FileMetadataRow.php b/src/core/etl/src/Flow/ETL/Extractor/File/FileMetadataRow.php
new file mode 100644
index 0000000000..d5dbc02d79
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/FileMetadataRow.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Extractor\File;
+
+use Flow\Filesystem\FileStatus;
+
+final readonly class FileMetadataRow implements ListedFileRow
+{
+    public function row(FileStatus $status): array
+    {
+        $extension = $status->path->extension();
+
+        return [
+            'path' => $status->path->path(),
+            'protocol' => $status->path->protocol(),
+            'file_name' => $status->path->filename(),
+            'base_name' => $status->path->basename(),
+            'is_file' => $status->isFile(),
+            'is_dir' => $status->isDirectory(),
+            // Path::extension() answers false for an extensionless file; the column is one
+            // type, so the absence is spelled null rather than a boolean in a string column.
+            'extension' => $extension === false ? null : $extension,
+        ];
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/FileReadLoop.php b/src/core/etl/src/Flow/ETL/Extractor/File/FileReadLoop.php
index 3375c2b4d1..6080039d8c 100644
--- a/src/core/etl/src/Flow/ETL/Extractor/File/FileReadLoop.php
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/FileReadLoop.php
@@ -4,8 +4,10 @@
 
 namespace Flow\ETL\Extractor\File;
 
-use Flow\ETL\Column\Backend;
 use Flow\ETL\Extractor\Signal;
+use Flow\ETL\FlowContext;
+use Flow\ETL\Function\Evaluation\Filter;
+use Flow\ETL\Function\ScalarFunction;
 use Flow\ETL\Rows;
 use Flow\ETL\Schema;
 use Generator;
@@ -14,9 +16,13 @@
 
 final readonly class FileReadLoop
 {
+    /**
+     * @param list<ScalarFunction> $conjuncts FileScan::$conjuncts
+     */
     public function __construct(
         private FileColumns $fileColumns,
         private Schema $schema,
+        private array $conjuncts = [],
     ) {}
 
     /**
@@ -29,17 +35,20 @@ public function read(
         array $sources,
         FileBatches $batches,
         int $batchSize,
-        Backend $backend,
+        FlowContext $context,
         ReadWindow $window,
     ): Generator {
         $body = $this->fileColumns->withoutTail($this->schema);
+        $backend = $context->backend();
+        $filter = Filter::bind($this->schema, ...$this->conjuncts);
         $offset = $window->offset;
         $skips = $batches instanceof OffsetSkippingFileBatches;
         $yielded = 0;
 
         foreach ($sources as $source) {
             $constants = $this->fileColumns->forFile($source, $this->schema);
-            $wanted = $window->limit === null ? null : $window->limit - $yielded;
+            // a limit counts the rows the filter keeps, which a format would count before it
+            $wanted = $window->limit === null || $this->conjuncts !== [] ? null : $window->limit - $yielded;
             $file = $batches->batches(
                 $source,
                 $body,
@@ -63,11 +72,16 @@ public function read(
                     $batch = $batch->slice($skipped, $batch->count() - $skipped);
                 }
 
-                if ($window->limit !== null && $batch->count() > ($window->limit - $yielded)) {
-                    $batch = $batch->slice(0, $window->limit - $yielded);
+                $rows = $filter->filter($constants->fillRows($batch, $this->schema, $backend), $context);
+
+                if ($rows->isEmpty()) {
+                    continue;
+                }
+
+                if ($window->limit !== null && $rows->count() > ($window->limit - $yielded)) {
+                    $rows = $rows->slice(0, $window->limit - $yielded);
                 }
 
-                $rows = $constants->fillRows($batch, $this->schema, $backend);
                 $yielded += $rows->count();
                 $signal = yield $rows;
 
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/FileScan.php b/src/core/etl/src/Flow/ETL/Extractor/File/FileScan.php
new file mode 100644
index 0000000000..2d43e85028
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/FileScan.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Extractor\File;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Function\Conjuncts;
+use Flow\ETL\Function\ScalarFunction;
+use Flow\Filesystem\Path\Filter;
+use Flow\Filesystem\Path\Filter\Filters;
+use Flow\Filesystem\Path\Filter\OnlyFiles;
+
+use function min;
+
+final readonly class FileScan
+{
+    /**
+     * @var null|int<1, max>
+     */
+    public ?int $limit;
+
+    /**
+     * @param null|int $limit the rows the plan needs, see Extractor::extract()
+     * @param Filter $pathFilter what this read lists
+     * @param list<ScalarFunction> $conjuncts predicates over the source's columns, in push order; the source returns
+     *                                        only rows matching every one, and $limit counts those rows
+     *
+     * @throws InvalidArgumentException when $limit is not greater than 0
+     */
+    public function __construct(
+        ?int $limit = null,
+        public Filter $pathFilter = new OnlyFiles(),
+        public array $conjuncts = [],
+    ) {
+        if ($limit !== null && $limit <= 0) {
+            throw new InvalidArgumentException('Limit must be greater than 0');
+        }
+
+        $this->limit = $limit;
+    }
+
+    public function narrows(): bool
+    {
+        return $this->limit !== null || !$this->pathFilter instanceof OnlyFiles || $this->conjuncts !== [];
+    }
+
+    public function withFilter(ScalarFunction $filter): self
+    {
+        return new self($this->limit, $this->pathFilter, [...$this->conjuncts, ...(new Conjuncts())->of($filter)]);
+    }
+
+    /**
+     * Narrowing only: a second push may lower the limit, never raise it.
+     *
+     * @throws InvalidArgumentException when $limit is not greater than 0
+     */
+    public function withLimit(int $limit): self
+    {
+        return new self(
+            $this->limit === null ? $limit : min($this->limit, $limit),
+            $this->pathFilter,
+            $this->conjuncts,
+        );
+    }
+
+    public function withPathFilter(Filter $filter): self
+    {
+        return new self(
+            $this->limit,
+            $this->pathFilter instanceof Filters
+                ? $this->pathFilter->add($filter)
+                : new Filters($this->pathFilter, $filter),
+            $this->conjuncts,
+        );
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/ListedFileRow.php b/src/core/etl/src/Flow/ETL/Extractor/File/ListedFileRow.php
new file mode 100644
index 0000000000..ada03cbc48
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/ListedFileRow.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Extractor\File;
+
+use Flow\Filesystem\FileStatus;
+
+interface ListedFileRow
+{
+    /**
+     * @return array<string, mixed> the row of one listed file, its partition columns left out
+     */
+    public function row(FileStatus $status): array;
+}
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/ListingScan.php b/src/core/etl/src/Flow/ETL/Extractor/File/ListingScan.php
new file mode 100644
index 0000000000..0dae904f41
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/ListingScan.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Extractor\File;
+
+use Flow\ETL\Extractor\Signal;
+use Flow\ETL\FlowContext;
+use Flow\ETL\Function\Evaluation\Filter;
+use Flow\ETL\Rows;
+use Flow\ETL\Rows\RowsBuilder;
+use Flow\ETL\Schema;
+use Flow\Filesystem\FileListing;
+use Flow\Filesystem\FileStatus;
+use Flow\Filesystem\Filesystem;
+use Flow\Filesystem\Path;
+use Generator;
+
+use function Flow\Types\DSL\type_instance_of;
+
+final readonly class ListingScan
+{
+    public function __construct(
+        private Filesystem $filesystem,
+        private Path $path,
+        private FileColumns $fileColumns,
+        private ListedFileRow $row,
+    ) {}
+
+    /**
+     * @param int<1, max> $batchSize
+     *
+     * @return Generator<int, Rows, null|Signal, void>
+     */
+    public function scan(FlowContext $context, FileScan $scan, Schema $schema, int $batchSize): Generator
+    {
+        $backend = $context->backend();
+        $filter = Filter::bind($schema, ...$scan->conjuncts);
+        $builder = new RowsBuilder($schema, $backend);
+        $yielded = 0;
+        $listing = (new FileListing($this->filesystem))->list($this->path, $scan->pathFilter);
+
+        while ($listing->valid()) {
+            $fileStatus = type_instance_of(FileStatus::class)->assert($listing->current());
+            $listing->next();
+
+            $builder->append([
+                ...$this->row->row($fileStatus),
+                ...$this->fileColumns->forFile(new SourceFile($fileStatus->path, $fileStatus->size), $schema)->values(),
+            ]);
+
+            if ($builder->count() < $batchSize && $listing->valid()) {
+                continue;
+            }
+
+            $rows = $filter->filter($builder->finish(), $context);
+            $builder = new RowsBuilder($schema, $backend);
+
+            if ($rows->isEmpty()) {
+                continue;
+            }
+
+            if ($scan->limit !== null && $rows->count() > ($scan->limit - $yielded)) {
+                $rows = $rows->slice(0, $scan->limit - $yielded);
+            }
+
+            $yielded += $rows->count();
+            $signal = yield $rows;
+
+            if ($signal === Signal::STOP) {
+                return;
+            }
+
+            if ($scan->limit !== null && $yielded >= $scan->limit) {
+                return;
+            }
+        }
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/PathPartitionsRow.php b/src/core/etl/src/Flow/ETL/Extractor/File/PathPartitionsRow.php
new file mode 100644
index 0000000000..b9fdf9267f
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/PathPartitionsRow.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Extractor\File;
+
+use Flow\Filesystem\FileStatus;
+use Flow\Filesystem\Partition;
+
+use function array_map;
+use function array_merge;
+use function array_values;
+
+final readonly class PathPartitionsRow implements ListedFileRow
+{
+    public function row(FileStatus $status): array
+    {
+        return [
+            'path' => $status->path->uri(),
+            'partitions' => array_merge(...array_values(array_map(static fn(Partition $p) => [
+                $p->name => $p->value,
+            ], $status->path->partitions()->toArray()))),
+        ];
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Extractor/File/Scanning.php b/src/core/etl/src/Flow/ETL/Extractor/File/Scanning.php
new file mode 100644
index 0000000000..9d6ec43bfe
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Extractor/File/Scanning.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Extractor\File;
+
+use Flow\ETL\Extractor\Signal;
+use Flow\ETL\FlowContext;
+use Flow\ETL\Rows;
+use Generator;
+
+/**
+ * @require-implements FileExtractor
+ */
+trait Scanning
+{
+    /**
+     * @return Generator<int, Rows, null|Signal, void>
+     */
+    public function extract(FlowContext $context, ?int $limit = null): Generator
+    {
+        return $this->scan($context, new FileScan(limit: $limit));
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Extractor/FilesExtractor.php b/src/core/etl/src/Flow/ETL/Extractor/FilesExtractor.php
index 41295a8a14..3924b29ebb 100644
--- a/src/core/etl/src/Flow/ETL/Extractor/FilesExtractor.php
+++ b/src/core/etl/src/Flow/ETL/Extractor/FilesExtractor.php
@@ -8,17 +8,19 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Extractor;
 use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileMetadataRow;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\ListedFiles;
 use Flow\ETL\Extractor\File\ListingPartitions;
-use Flow\ETL\Extractor\File\SourceFile;
+use Flow\ETL\Extractor\File\ListingScan;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\FlowContext;
-use Flow\ETL\Rows\RowsBuilder;
+use Flow\ETL\Rows;
 use Flow\ETL\Schema;
 use Flow\Filesystem\FileListing;
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
 use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
@@ -34,6 +36,7 @@ final class FilesExtractor implements BatchableExtractor, Extractor, FileExtract
     private ?Statistics $statistics = null;
 
     use Batches;
+    use Scanning;
     use ListingPartitions;
 
     private readonly Filesystem $filesystem;
@@ -61,56 +64,16 @@ public function isRepeatable(): bool
     }
 
     /**
-     * @return Generator<int, \Flow\ETL\Rows, Signal|null, void>
+     * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
-        $batchSize = $this->batchSize();
-        $backend = $context->backend();
-        $fileColumns = $this->fileColumns($this->filesystem, $this->path);
-        $schema = $this->schema();
-        $builder = new RowsBuilder($schema, $backend);
-        $yielded = 0;
-
-        foreach ((new FileListing($this->filesystem))->list($this->path, $pathFilter) as $fileStatus) {
-            $extension = $fileStatus->path->extension();
-
-            $builder->append([
-                'path' => $fileStatus->path->path(),
-                'protocol' => $fileStatus->path->protocol(),
-                'file_name' => $fileStatus->path->filename(),
-                'base_name' => $fileStatus->path->basename(),
-                'is_file' => $fileStatus->isFile(),
-                'is_dir' => $fileStatus->isDirectory(),
-                // Path::extension() answers false for an extensionless file; the column is one
-                // type, so the absence is spelled null rather than a boolean in a string column.
-                'extension' => $extension === false ? null : $extension,
-                ...$fileColumns->forFile(new SourceFile($fileStatus->path, $fileStatus->size), $schema)->values(),
-            ]);
-
-            if ($builder->count() < $batchSize) {
-                continue;
-            }
-
-            $rows = $builder->finish();
-            $yielded += $rows->count();
-
-            $signal = yield $rows;
-
-            if ($signal === Signal::STOP) {
-                return;
-            }
-
-            $builder = new RowsBuilder($schema, $backend);
-
-            if ($limit !== null && $yielded >= $limit) {
-                return;
-            }
-        }
-
-        if ($builder->count() > 0) {
-            yield $builder->finish();
-        }
+        return (new ListingScan(
+            $this->filesystem,
+            $this->path,
+            $this->fileColumns($this->filesystem, $this->path),
+            new FileMetadataRow(),
+        ))->scan($context, $scan, $this->schema(), $this->batchSize());
     }
 
     public function partitionSchema(): Schema
diff --git a/src/core/etl/src/Flow/ETL/Extractor/PathPartitionsExtractor.php b/src/core/etl/src/Flow/ETL/Extractor/PathPartitionsExtractor.php
index d9a9fd0220..9713a9c95a 100644
--- a/src/core/etl/src/Flow/ETL/Extractor/PathPartitionsExtractor.php
+++ b/src/core/etl/src/Flow/ETL/Extractor/PathPartitionsExtractor.php
@@ -8,23 +8,21 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Extractor;
 use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\ListingPartitions;
-use Flow\ETL\Extractor\File\SourceFile;
+use Flow\ETL\Extractor\File\ListingScan;
+use Flow\ETL\Extractor\File\PathPartitionsRow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\FlowContext;
-use Flow\ETL\Rows\RowsBuilder;
+use Flow\ETL\Rows;
 use Flow\ETL\Schema;
 use Flow\Filesystem\FileListing;
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
-use Flow\Filesystem\Partition;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
 use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
-use function array_map;
-use function array_merge;
-use function array_values;
 use function Flow\ETL\DSL\map_schema;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
@@ -40,6 +38,7 @@ final class PathPartitionsExtractor implements BatchableExtractor, Extractor, Fi
     private ?Statistics $statistics = null;
 
     use Batches;
+    use Scanning;
     use ListingPartitions;
 
     private readonly Filesystem $filesystem;
@@ -67,49 +66,16 @@ public function isRepeatable(): bool
     }
 
     /**
-     * @return Generator<int, \Flow\ETL\Rows, Signal|null, void>
+     * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
-        $batchSize = $this->batchSize();
-        $backend = $context->backend();
-        $fileColumns = $this->fileColumns($this->filesystem, $this->path);
-        $schema = $this->schema();
-        $builder = new RowsBuilder($schema, $backend);
-        $yielded = 0;
-
-        foreach ((new FileListing($this->filesystem))->list($this->path, $pathFilter) as $fileStatus) {
-            $builder->append([
-                'path' => $fileStatus->path->uri(),
-                'partitions' => array_merge(...array_values(array_map(static fn(Partition $p) => [
-                    $p->name => $p->value,
-                ], $fileStatus->path->partitions()->toArray()))),
-                ...$fileColumns->forFile(new SourceFile($fileStatus->path, $fileStatus->size), $schema)->values(),
-            ]);
-
-            if ($builder->count() < $batchSize) {
-                continue;
-            }
-
-            $rows = $builder->finish();
-            $yielded += $rows->count();
-
-            $signal = yield $rows;
-
-            if ($signal === Signal::STOP) {
-                return;
-            }
-
-            $builder = new RowsBuilder($schema, $backend);
-
-            if ($limit !== null && $yielded >= $limit) {
-                return;
-            }
-        }
-
-        if ($builder->count() > 0) {
-            yield $builder->finish();
-        }
+        return (new ListingScan(
+            $this->filesystem,
+            $this->path,
+            $this->fileColumns($this->filesystem, $this->path),
+            new PathPartitionsRow(),
+        ))->scan($context, $scan, $this->schema(), $this->batchSize());
     }
 
     public function partitionSchema(): Schema
diff --git a/src/core/etl/src/Flow/ETL/FlowPhpExtension.php b/src/core/etl/src/Flow/ETL/FlowPhpExtension.php
index 20844015ee..0569a67795 100644
--- a/src/core/etl/src/Flow/ETL/FlowPhpExtension.php
+++ b/src/core/etl/src/Flow/ETL/FlowPhpExtension.php
@@ -18,7 +18,7 @@
      * The contract version this package expects from flow_php, equal to the extension's FLOW_PHP_ABI. Both sides change
      * together whenever a class or interface the extension registers changes.
      */
-    public const int ABI = 1;
+    public const int ABI = 2;
 
     public function __construct(
         public bool $loaded,
diff --git a/src/core/etl/src/Flow/ETL/Function/Between.php b/src/core/etl/src/Flow/ETL/Function/Between.php
index 89f9dd2e83..7edc5f315a 100644
--- a/src/core/etl/src/Flow/ETL/Function/Between.php
+++ b/src/core/etl/src/Flow/ETL/Function/Between.php
@@ -111,6 +111,7 @@ public function eval(Rows $rows, FlowContext $context): Column
         [$values, $lowerBounds, $upperBounds] = array_map(static fn(Column $column): array => $sameType
             ? $comparable->ordering($column)
             : $column->values(), $columns);
+        $order = new ValueOrder(...array_map(static fn(Column $column): Type => $column->type(), $columns));
         $results = [];
         $i = 0;
 
@@ -120,7 +121,7 @@ public function eval(Rows $rows, FlowContext $context): Column
                     throw new InvalidArgumentException('Between function requires valid boundary');
                 }
 
-                $results[] = $boundary->compare($values[$i], $lowerBounds[$i], $upperBounds[$i]);
+                $results[] = $boundary->compare($values[$i], $lowerBounds[$i], $upperBounds[$i], $order);
             }
         } catch (Exception $e) {
             throw EvaluationException::at($i, $e);
diff --git a/src/core/etl/src/Flow/ETL/Function/Between/Boundary.php b/src/core/etl/src/Flow/ETL/Function/Between/Boundary.php
index 20e538645d..c7b181d281 100644
--- a/src/core/etl/src/Flow/ETL/Function/Between/Boundary.php
+++ b/src/core/etl/src/Flow/ETL/Function/Between/Boundary.php
@@ -4,15 +4,7 @@
 
 namespace Flow\ETL\Function\Between;
 
-use DateInterval;
-use DateTimeImmutable;
-use DateTimeInterface;
-use Flow\ETL\Exception\InvalidArgumentException;
-
-use function is_array;
-use function is_bool;
-use function is_numeric;
-use function is_string;
+use Flow\ETL\Function\ValueOrder;
 
 enum Boundary
 {
@@ -21,8 +13,12 @@ enum Boundary
     case LEFT_INCLUSIVE;
     case RIGHT_INCLUSIVE;
 
-    public function compare(mixed $value, mixed $lowerBound, mixed $upperbound): ?bool
-    {
+    public function compare(
+        mixed $value,
+        mixed $lowerBound,
+        mixed $upperbound,
+        ValueOrder $order = new ValueOrder(),
+    ): ?bool {
         if ($value === null) {
             return null;
         }
@@ -31,8 +27,8 @@ public function compare(mixed $value, mixed $lowerBound, mixed $upperbound): ?bo
 
         if ($lowerBound !== null) {
             $aboveLower = match ($this) {
-                self::INCLUSIVE, self::LEFT_INCLUSIVE => $this->compareValues($value, $lowerBound) >= 0,
-                self::EXCLUSIVE, self::RIGHT_INCLUSIVE => $this->compareValues($value, $lowerBound) > 0,
+                self::INCLUSIVE, self::LEFT_INCLUSIVE => $order->compare($lowerBound, $value) <= 0,
+                self::EXCLUSIVE, self::RIGHT_INCLUSIVE => $order->compare($lowerBound, $value) < 0,
             };
         }
 
@@ -40,8 +36,8 @@ public function compare(mixed $value, mixed $lowerBound, mixed $upperbound): ?bo
 
         if ($upperbound !== null) {
             $belowUpper = match ($this) {
-                self::INCLUSIVE, self::RIGHT_INCLUSIVE => $this->compareValues($value, $upperbound) <= 0,
-                self::EXCLUSIVE, self::LEFT_INCLUSIVE => $this->compareValues($value, $upperbound) < 0,
+                self::INCLUSIVE, self::RIGHT_INCLUSIVE => $order->compare($value, $upperbound) <= 0,
+                self::EXCLUSIVE, self::LEFT_INCLUSIVE => $order->compare($value, $upperbound) < 0,
             };
         }
 
@@ -56,37 +52,4 @@ public function compare(mixed $value, mixed $lowerBound, mixed $upperbound): ?bo
 
         return true;
     }
-
-    public function compareValues(mixed $left, mixed $right): int
-    {
-        if (is_numeric($left) && is_numeric($right)) {
-            return (float) $left <=> (float) $right;
-        }
-
-        if (is_string($left) && is_string($right)) {
-            return $left <=> $right;
-        }
-
-        if ($left instanceof DateTimeInterface && $right instanceof DateTimeInterface) {
-            return $left <=> $right;
-        }
-
-        if ($left instanceof DateInterval && $right instanceof DateInterval) {
-            $reference = new DateTimeImmutable('@0');
-
-            return $reference->add($left) <=> $reference->add($right);
-        }
-
-        if (is_bool($left) && is_bool($right)) {
-            return $left <=> $right;
-        }
-
-        if (is_array($left) && is_array($right)) {
-            return $left <=> $right;
-        }
-
-        throw new InvalidArgumentException(
-            'Boundary::compare requires value and bounds to be of a comparable type (numeric, string, DateTimeInterface, DateInterval, bool, or array).',
-        );
-    }
 }
diff --git a/src/core/etl/src/Flow/ETL/Function/Conjuncts.php b/src/core/etl/src/Flow/ETL/Function/Conjuncts.php
new file mode 100644
index 0000000000..e6a5e5dcbf
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Function/Conjuncts.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Function;
+
+use function array_merge;
+
+final readonly class Conjuncts
+{
+    /**
+     * @return list<ScalarFunction>
+     */
+    public function of(ScalarFunction $function): array
+    {
+        if (!$function instanceof All) {
+            return [$function];
+        }
+
+        $conjuncts = [];
+
+        foreach ($function->children() as $child) {
+            $conjuncts[] = $this->of($child);
+        }
+
+        return array_merge(...$conjuncts);
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Function/Evaluation/Filter.php b/src/core/etl/src/Flow/ETL/Function/Evaluation/Filter.php
new file mode 100644
index 0000000000..ee2da8bdad
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Function/Evaluation/Filter.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Function\Evaluation;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\FlowContext;
+use Flow\ETL\Function\ExpandingFunctions;
+use Flow\ETL\Function\ReferenceResolver;
+use Flow\ETL\Function\ScalarFunction;
+use Flow\ETL\Rows;
+use Flow\ETL\Schema;
+
+use function array_keys;
+use function count;
+use function Flow\Types\DSL\type_bare;
+use function Flow\Types\DSL\type_boolean;
+use function Flow\Types\DSL\type_equals;
+use function range;
+use function sprintf;
+
+final readonly class Filter
+{
+    /**
+     * @param list<ScalarFunction> $predicates resolved against the bound schema
+     */
+    private function __construct(
+        private array $predicates,
+    ) {}
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public static function bind(Schema $schema, ScalarFunction ...$predicates): self
+    {
+        $resolver = new ReferenceResolver();
+        $resolved = [];
+
+        foreach ($predicates as $predicate) {
+            $function = $resolver->resolve($predicate, $schema);
+            $resolver->assertResolved($function, $schema);
+            (new ExpandingFunctions())->refuse($function, 'filter');
+
+            // type_bare() keeps the gate blind to nullability - a null-propagating predicate declares
+            // ?boolean, and a NULL row is dropped like a false one.
+            if (!type_equals(type_bare($function->returns()), type_boolean())) {
+                throw new InvalidArgumentException(sprintf(
+                    'filter() requires a predicate returning boolean, "%s" returns "%s". '
+                    . 'Use an explicit comparison, e.g. ->notEquals(lit(0)).',
+                    $function::class,
+                    $function->returns()->toString(),
+                ));
+            }
+
+            $resolved[] = $function;
+        }
+
+        return new self($resolved);
+    }
+
+    /**
+     * The rows every predicate is TRUE for: each is evaluated only on the rows the ones before it kept.
+     */
+    public function filter(Rows $rows, FlowContext $context): Rows
+    {
+        if ($this->predicates === []) {
+            return $rows;
+        }
+
+        $kept = $rows->isEmpty() ? [] : range(0, $rows->count() - 1);
+
+        foreach ($this->predicates as $predicate) {
+            if ($kept === []) {
+                break;
+            }
+
+            $truths = array_keys(
+                (new Selection($kept))
+                    ->evaluate($predicate, $rows, $context)
+                    ->physicals(),
+                true,
+                true,
+            );
+
+            if (count($kept) === $rows->count()) {
+                $kept = $truths;
+
+                continue;
+            }
+
+            $next = [];
+
+            foreach ($truths as $row) {
+                $next[] = $kept[$row];
+            }
+
+            $kept = $next;
+        }
+
+        return count($kept) === $rows->count() ? $rows : $rows->gather($kept);
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Function/GreaterThan.php b/src/core/etl/src/Flow/ETL/Function/GreaterThan.php
index d87f2fd5c2..066e2cdb41 100644
--- a/src/core/etl/src/Flow/ETL/Function/GreaterThan.php
+++ b/src/core/etl/src/Flow/ETL/Function/GreaterThan.php
@@ -4,8 +4,6 @@
 
 namespace Flow\ETL\Function;
 
-use DateInterval;
-use DateTimeImmutable;
 use Exception;
 use Flow\ETL\Column\Column;
 use Flow\ETL\Column\ComparableValues;
@@ -85,6 +83,7 @@ public function eval(Rows $rows, FlowContext $context): Column
         [$lefts, $rights] = type_bare($leftColumn->type())::class === type_bare($rightColumn->type())::class
             ? [$comparable->ordering($leftColumn), $comparable->ordering($rightColumn)]
             : [$leftColumn->values(), $rightColumn->values()];
+        $order = new ValueOrder($leftColumn->type(), $rightColumn->type());
         $results = [];
         $i = 0;
 
@@ -100,17 +99,7 @@ public function eval(Rows $rows, FlowContext $context): Column
                     continue;
                 }
 
-                // The dispatch picks a comparison strategy from the values, never a column type - bind has
-                // already proved the pair comparable in returns().
-                if ($left instanceof DateInterval && $right instanceof DateInterval) {
-                    $reference = new DateTimeImmutable('@0');
-                    $results[] = $reference->add($left) > $reference->add($right);
-
-                    continue;
-                }
-
-                // @mago-expect analysis:mixed-operand(2)
-                $results[] = $left > $right;
+                $results[] = $order->compare($right, $left) < 0;
             }
         } catch (Exception $e) {
             throw EvaluationException::at($i, $e);
diff --git a/src/core/etl/src/Flow/ETL/Function/GreaterThanEqual.php b/src/core/etl/src/Flow/ETL/Function/GreaterThanEqual.php
index 41d7f760df..827371c05c 100644
--- a/src/core/etl/src/Flow/ETL/Function/GreaterThanEqual.php
+++ b/src/core/etl/src/Flow/ETL/Function/GreaterThanEqual.php
@@ -4,8 +4,6 @@
 
 namespace Flow\ETL\Function;
 
-use DateInterval;
-use DateTimeImmutable;
 use Exception;
 use Flow\ETL\Column\Column;
 use Flow\ETL\Column\ComparableValues;
@@ -85,6 +83,7 @@ public function eval(Rows $rows, FlowContext $context): Column
         [$lefts, $rights] = type_bare($leftColumn->type())::class === type_bare($rightColumn->type())::class
             ? [$comparable->ordering($leftColumn), $comparable->ordering($rightColumn)]
             : [$leftColumn->values(), $rightColumn->values()];
+        $order = new ValueOrder($leftColumn->type(), $rightColumn->type());
         $results = [];
         $i = 0;
 
@@ -100,17 +99,7 @@ public function eval(Rows $rows, FlowContext $context): Column
                     continue;
                 }
 
-                // The dispatch picks a comparison strategy from the values, never a column type - bind has
-                // already proved the pair comparable in returns().
-                if ($left instanceof DateInterval && $right instanceof DateInterval) {
-                    $reference = new DateTimeImmutable('@0');
-                    $results[] = $reference->add($left) >= $reference->add($right);
-
-                    continue;
-                }
-
-                // @mago-expect analysis:mixed-operand(2)
-                $results[] = $left >= $right;
+                $results[] = $order->compare($right, $left) <= 0;
             }
         } catch (Exception $e) {
             throw EvaluationException::at($i, $e);
diff --git a/src/core/etl/src/Flow/ETL/Function/Greatest.php b/src/core/etl/src/Flow/ETL/Function/Greatest.php
index ac6f45fa1e..abae972f82 100644
--- a/src/core/etl/src/Flow/ETL/Function/Greatest.php
+++ b/src/core/etl/src/Flow/ETL/Function/Greatest.php
@@ -16,7 +16,6 @@
 use function array_map;
 use function array_values;
 use function Flow\ETL\DSL\lit;
-use function max;
 
 final class Greatest implements ScalarFunction
 {
@@ -73,23 +72,33 @@ public function returns(): Type
 
     public function eval(Rows $rows, FlowContext $context): Column
     {
-        $arguments = array_map(static fn(ScalarFunction $value): array => (new Parameter($value))->values(
+        $columns = array_map(static fn(ScalarFunction $value): Column => (new Parameter($value))->column(
             $rows,
             $context,
         ), $this->values);
+        $order = new ValueOrder(...array_map(static fn(Column $column): Type => $column->type(), $columns));
+        $arguments = array_map(static fn(Column $column): array => $column->values(), $columns);
         $results = [];
 
         for ($i = 0, $count = $rows->count(); $i < $count; $i++) {
             // NULL iff every argument is NULL - nulls are skipped, never compared
-            $values = [];
+            $greatest = null;
 
             foreach ($arguments as $argument) {
-                if ($argument[$i] !== null) {
-                    $values[] = $argument[$i];
+                // @mago-ignore analysis:mixed-assignment
+                $value = $argument[$i];
+
+                if ($value === null) {
+                    continue;
+                }
+
+                if ($greatest === null || $order->compare($greatest, $value) < 0) {
+                    // @mago-ignore analysis:mixed-assignment
+                    $greatest = $value;
                 }
             }
 
-            $results[] = $values === [] ? null : max($values);
+            $results[] = $greatest;
         }
 
         return (new ResultColumn($context->backend()))->of($this, $results);
diff --git a/src/core/etl/src/Flow/ETL/Function/Least.php b/src/core/etl/src/Flow/ETL/Function/Least.php
index c89fd37a4e..ecabdee12f 100644
--- a/src/core/etl/src/Flow/ETL/Function/Least.php
+++ b/src/core/etl/src/Flow/ETL/Function/Least.php
@@ -16,7 +16,6 @@
 use function array_map;
 use function array_values;
 use function Flow\ETL\DSL\lit;
-use function min;
 
 final class Least implements ScalarFunction
 {
@@ -73,23 +72,33 @@ public function returns(): Type
 
     public function eval(Rows $rows, FlowContext $context): Column
     {
-        $arguments = array_map(static fn(ScalarFunction $value): array => (new Parameter($value))->values(
+        $columns = array_map(static fn(ScalarFunction $value): Column => (new Parameter($value))->column(
             $rows,
             $context,
         ), $this->values);
+        $order = new ValueOrder(...array_map(static fn(Column $column): Type => $column->type(), $columns));
+        $arguments = array_map(static fn(Column $column): array => $column->values(), $columns);
         $results = [];
 
         for ($i = 0, $count = $rows->count(); $i < $count; $i++) {
             // NULL iff every argument is NULL - nulls are skipped, never compared
-            $values = [];
+            $least = null;
 
             foreach ($arguments as $argument) {
-                if ($argument[$i] !== null) {
-                    $values[] = $argument[$i];
+                // @mago-ignore analysis:mixed-assignment
+                $value = $argument[$i];
+
+                if ($value === null) {
+                    continue;
+                }
+
+                if ($least === null || $order->compare($value, $least) < 0) {
+                    // @mago-ignore analysis:mixed-assignment
+                    $least = $value;
                 }
             }
 
-            $results[] = $values === [] ? null : min($values);
+            $results[] = $least;
         }
 
         return (new ResultColumn($context->backend()))->of($this, $results);
diff --git a/src/core/etl/src/Flow/ETL/Function/LessThan.php b/src/core/etl/src/Flow/ETL/Function/LessThan.php
index c644f4c1c6..57ab86434b 100644
--- a/src/core/etl/src/Flow/ETL/Function/LessThan.php
+++ b/src/core/etl/src/Flow/ETL/Function/LessThan.php
@@ -4,8 +4,6 @@
 
 namespace Flow\ETL\Function;
 
-use DateInterval;
-use DateTimeImmutable;
 use Exception;
 use Flow\ETL\Column\Column;
 use Flow\ETL\Column\ComparableValues;
@@ -85,6 +83,7 @@ public function eval(Rows $rows, FlowContext $context): Column
         [$lefts, $rights] = type_bare($leftColumn->type())::class === type_bare($rightColumn->type())::class
             ? [$comparable->ordering($leftColumn), $comparable->ordering($rightColumn)]
             : [$leftColumn->values(), $rightColumn->values()];
+        $order = new ValueOrder($leftColumn->type(), $rightColumn->type());
         $results = [];
         $i = 0;
 
@@ -100,17 +99,7 @@ public function eval(Rows $rows, FlowContext $context): Column
                     continue;
                 }
 
-                // The dispatch picks a comparison strategy from the values, never a column type - bind has
-                // already proved the pair comparable in returns().
-                if ($left instanceof DateInterval && $right instanceof DateInterval) {
-                    $reference = new DateTimeImmutable('@0');
-                    $results[] = $reference->add($left) < $reference->add($right);
-
-                    continue;
-                }
-
-                // @mago-expect analysis:mixed-operand(2)
-                $results[] = $left < $right;
+                $results[] = $order->compare($left, $right) < 0;
             }
         } catch (Exception $e) {
             throw EvaluationException::at($i, $e);
diff --git a/src/core/etl/src/Flow/ETL/Function/LessThanEqual.php b/src/core/etl/src/Flow/ETL/Function/LessThanEqual.php
index c94d5de930..589b6e392d 100644
--- a/src/core/etl/src/Flow/ETL/Function/LessThanEqual.php
+++ b/src/core/etl/src/Flow/ETL/Function/LessThanEqual.php
@@ -4,8 +4,6 @@
 
 namespace Flow\ETL\Function;
 
-use DateInterval;
-use DateTimeImmutable;
 use Exception;
 use Flow\ETL\Column\Column;
 use Flow\ETL\Column\ComparableValues;
@@ -85,6 +83,7 @@ public function eval(Rows $rows, FlowContext $context): Column
         [$lefts, $rights] = type_bare($leftColumn->type())::class === type_bare($rightColumn->type())::class
             ? [$comparable->ordering($leftColumn), $comparable->ordering($rightColumn)]
             : [$leftColumn->values(), $rightColumn->values()];
+        $order = new ValueOrder($leftColumn->type(), $rightColumn->type());
         $results = [];
         $i = 0;
 
@@ -100,17 +99,7 @@ public function eval(Rows $rows, FlowContext $context): Column
                     continue;
                 }
 
-                // The dispatch picks a comparison strategy from the values, never a column type - bind has
-                // already proved the pair comparable in returns().
-                if ($left instanceof DateInterval && $right instanceof DateInterval) {
-                    $reference = new DateTimeImmutable('@0');
-                    $results[] = $reference->add($left) <= $reference->add($right);
-
-                    continue;
-                }
-
-                // @mago-expect analysis:mixed-operand(2)
-                $results[] = $left <= $right;
+                $results[] = $order->compare($left, $right) <= 0;
             }
         } catch (Exception $e) {
             throw EvaluationException::at($i, $e);
diff --git a/src/core/etl/src/Flow/ETL/Function/ValueOrder.php b/src/core/etl/src/Flow/ETL/Function/ValueOrder.php
new file mode 100644
index 0000000000..d3eacc304a
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Function/ValueOrder.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Function;
+
+use DateInterval;
+use DateTimeImmutable;
+use Flow\Types\Type;
+use Flow\Types\Type\Logical\NumericStringType;
+
+use function Flow\Types\DSL\type_bare;
+use function is_string;
+use function strcmp;
+
+/**
+ * Two strings order by bytes, as sort does, unless an operand is a numeric string column, which orders numerically.
+ * Anything else orders as PHP's <=>, so `$a < $b` is `compare($a, $b) < 0` and `$a > $b` is `compare($b, $a) < 0`,
+ * NaN included.
+ */
+final readonly class ValueOrder
+{
+    private bool $numericStrings;
+
+    /**
+     * @param Type<mixed> ...$operands
+     */
+    public function __construct(Type ...$operands)
+    {
+        $numericStrings = false;
+
+        foreach ($operands as $operand) {
+            $numericStrings = $numericStrings || type_bare($operand) instanceof NumericStringType;
+        }
+
+        $this->numericStrings = $numericStrings;
+    }
+
+    public function compare(mixed $left, mixed $right): int
+    {
+        if (!$this->numericStrings && is_string($left) && is_string($right)) {
+            return strcmp($left, $right) <=> 0;
+        }
+
+        if ($left instanceof DateInterval && $right instanceof DateInterval) {
+            $reference = new DateTimeImmutable('@0');
+
+            return $reference->add($left) <=> $reference->add($right);
+        }
+
+        // @mago-expect analysis:mixed-operand(2)
+        return $left <=> $right;
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Optimizer.php b/src/core/etl/src/Flow/ETL/Optimizer.php
index 909def5325..bbb8c6103f 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer.php
@@ -37,8 +37,8 @@ public static function default(): self
         return new self(
             new CombineLimits(),
             new CombineSortAndLimit(),
-            new PushLimitIntoSource(),
             new PushFilterIntoSource(),
+            new PushLimitIntoSource(),
             new CountFromStatistics(),
             new PushProjectionIntoExpand(),
         );
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/FilterWalk.php b/src/core/etl/src/Flow/ETL/Optimizer/FilterWalk.php
index 098733d12f..016d69e024 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/FilterWalk.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/FilterWalk.php
@@ -35,9 +35,9 @@ public function reachedByEveryConsumer(Node\Filter $filter, Node ...$consumerInp
 
     /**
      * $predicate as $leaf sees it, or null when it may not be evaluated there instead of above $filter.
-     * Another Filter is TRANSPARENT here: it only removes rows, and the pushed Filter node stays, so pruning a
-     * file drops rows that filter would have dropped anyway. Limit/Offset/Until/Distinct/Discard are not: they
-     * make WHICH rows arrive depend on what the source read.
+     * Another Filter is TRANSPARENT here: it only removes rows, so the order two filters drop rows in does not change
+     * which rows survive both. Limit/Offset/Until/Distinct/Discard are not: they make WHICH rows arrive depend on
+     * what the source read.
      *
      * A node that redefines a column the predicate reads blocks it, unless the column is a plain alias of a
      * column below (Rename, a WithColumn of a bare reference): the predicate is rewritten to read that column.
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/JoinSides.php b/src/core/etl/src/Flow/ETL/Optimizer/JoinSides.php
index 2eea368fbb..26ac44d21e 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/JoinSides.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/JoinSides.php
@@ -21,15 +21,15 @@ public function __construct(
         private FlowContext $context,
     ) {}
 
-    public function of(Node $node): Node
+    public function of(Node $original, Node $rebuilt): Node
     {
-        if (!$node instanceof JoinsFrame) {
-            return $node;
+        if (!$rebuilt instanceof JoinsFrame) {
+            return $rebuilt;
         }
 
-        return $node->withChildren([
-            $node->children()[0],
-            $this->optimizer->optimize(new LogicalPlan($node->right()), $this->context)->root,
+        return $rebuilt->withChildren([
+            $rebuilt->children()[0],
+            $this->optimizer->optimize(new LogicalPlan($rebuilt->right()), $this->context)->root,
         ]);
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/Rule/CombineLimits.php b/src/core/etl/src/Flow/ETL/Optimizer/Rule/CombineLimits.php
index 6837db8868..a9d893143e 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/Rule/CombineLimits.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/Rule/CombineLimits.php
@@ -23,14 +23,16 @@ public function apply(LogicalPlan $plan, FlowContext $context): LogicalPlan
         return $plan->transformUp($this);
     }
 
-    public function of(Node $node): Node
+    public function of(Node $original, Node $rebuilt): Node
     {
-        if (!$node instanceof Limit) {
-            return $node;
+        if (!$rebuilt instanceof Limit) {
+            return $rebuilt;
         }
 
-        $child = $node->children()[0];
+        $child = $rebuilt->children()[0];
 
-        return $child instanceof Limit ? new Limit($child->children()[0], min($node->limit, $child->limit)) : $node;
+        return $child instanceof Limit
+            ? new Limit($child->children()[0], min($rebuilt->limit, $child->limit))
+            : $rebuilt;
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/Rule/CountFromStatistics.php b/src/core/etl/src/Flow/ETL/Optimizer/Rule/CountFromStatistics.php
index 6ab5bce034..ce90b859d6 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/Rule/CountFromStatistics.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/Rule/CountFromStatistics.php
@@ -11,7 +11,6 @@
 use Flow\ETL\Plan\Node\Read;
 use Flow\ETL\Plan\Node\Result;
 use Flow\ETL\Processor\CountingProcessor;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 
 use function Flow\ETL\DSL\from_rows;
 
@@ -22,7 +21,7 @@ public function apply(LogicalPlan $plan, FlowContext $context): LogicalPlan
         $count = $plan->root instanceof Result ? $plan->root->children()[0] : null;
         $read = $count instanceof Count ? $count->children()[0] : null;
 
-        if (!$read instanceof Read || $read->limit() !== null || !$read->pathFilter() instanceof OnlyFiles) {
+        if (!$read instanceof Read || $read->scan()->narrows()) {
             return $plan;
         }
 
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushFilterIntoSource.php b/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushFilterIntoSource.php
index 3d597af875..a696fdd9ca 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushFilterIntoSource.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushFilterIntoSource.php
@@ -8,19 +8,24 @@
 use Flow\ETL\Filesystem\ScalarFunctionFilter;
 use Flow\ETL\FlowContext;
 use Flow\ETL\Function\All;
+use Flow\ETL\Function\Conjuncts;
 use Flow\ETL\Function\ReferencedColumns;
 use Flow\ETL\Optimizer\FilterWalk;
 use Flow\ETL\Optimizer\Rule;
 use Flow\ETL\Plan\LogicalPlan;
 use Flow\ETL\Plan\Node;
-use Flow\ETL\Plan\ReplaceLeaf;
+use Flow\ETL\Plan\ReplaceNodes;
+use SplObjectStorage;
 
 use function array_diff;
+use function array_reverse;
+use function count;
 
 /**
- * Evaluate a partition-only predicate once per FILE instead of once per row: the file never opens. The Filter node
- * stays, so a source that lists more than the pushed filter admits still returns the right rows. The parts of an AND
- * that read only partition columns are pushed one by one; an OR is pushed only as a whole.
+ * Moves every deterministic part of an AND into the file source, which returns only the rows matching it; a
+ * partition-only part is also pushed as a path filter, so a file it rejects is never listed. A pushed part leaves its
+ * Filter node, and a node left with no part is removed. An OR is pushed only as a whole. Nodes are pushed leaf first;
+ * a part kept in a node stops the push of every part after it and of every node above it.
  */
 final readonly class PushFilterIntoSource implements Rule
 {
@@ -34,43 +39,70 @@ public function apply(LogicalPlan $plan, FlowContext $context): LogicalPlan
         }
 
         $partitions = $extractor->partitionSchema();
-
-        if ($partitions->count() === 0) {
-            return $plan;
-        }
-
         $consumerInputs = $plan->consumerInputs();
         $walk = new FilterWalk();
         $columns = new ReferencedColumns();
+        $conjuncts = new Conjuncts();
         $names = $partitions->references()->names();
         $read = $leaf;
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
+        $removals = [];
+        $filters = [];
 
         for ($node = $plan->root; $node->children() !== []; $node = $node->children()[0]) {
-            if (!$node instanceof Node\Filter || !$walk->reachedByEveryConsumer($node, ...$consumerInputs)) {
-                continue;
+            if ($node instanceof Node\Filter && $walk->reachedByEveryConsumer($node, ...$consumerInputs)) {
+                $filters[] = $node;
             }
+        }
 
-            foreach ($node->function instanceof All ? $node->function->children() : [$node->function] as $conjunct) {
-                if (!$conjunct->deterministic()) {
-                    continue;
-                }
+        // leaf first, so the source evaluates a lower filter before the one above it relies on what it removed
+        foreach (array_reverse($filters) as $filter) {
+            $parts = $conjuncts->of($filter->function);
+            $kept = [];
 
-                $atLeaf = $walk->predicateAtLeaf($node, $leaf, $conjunct);
+            foreach ($parts as $conjunct) {
+                // a conjunct after a kept one would be evaluated on rows the kept one removes
+                $atLeaf = $kept === [] && $conjunct->deterministic()
+                    ? $walk->predicateAtLeaf($filter, $leaf, $conjunct)
+                    : null;
 
                 if ($atLeaf === null) {
+                    $kept[] = $conjunct;
+
                     continue;
                 }
 
-                $refs = $columns->in($atLeaf);
+                $referenced = $columns->in($atLeaf)->names();
 
-                if ($refs->all() === [] || array_diff($refs->names(), $names) !== []) {
-                    continue;
+                if ($referenced !== [] && array_diff($referenced, $names) === []) {
+                    $read = $read->withPathFilter(new ScalarFunctionFilter($atLeaf, $partitions, $context));
                 }
 
-                $read = $read->withPathFilter(new ScalarFunctionFilter($atLeaf, $partitions, $context));
+                $read = $read->withFilter($atLeaf);
+            }
+
+            if ($kept === []) {
+                $removals[] = $filter;
+            } elseif (count($kept) !== count($parts)) {
+                $replacements[$filter] = new Node\Filter(
+                    $filter->children()[0],
+                    count($kept) === 1 ? $kept[0] : new All(...$kept),
+                );
             }
+
+            // a filter above a kept conjunct would be evaluated on rows that conjunct removes
+            if ($kept !== []) {
+                break;
+            }
+        }
+
+        if ($read !== $leaf) {
+            $replacements[$leaf] = $read;
         }
 
-        return $read === $leaf ? $plan : $plan->transformUp(new ReplaceLeaf($leaf, $read));
+        return $replacements->count() === 0 && $removals === []
+            ? $plan
+            : $plan->transformUp(new ReplaceNodes($replacements, $removals));
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushLimitIntoSource.php b/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushLimitIntoSource.php
index 36beb317b9..70edda1588 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushLimitIntoSource.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushLimitIntoSource.php
@@ -8,7 +8,7 @@
 use Flow\ETL\Optimizer\LimitWalk;
 use Flow\ETL\Optimizer\Rule;
 use Flow\ETL\Plan\LogicalPlan;
-use Flow\ETL\Plan\ReplaceLeaf;
+use Flow\ETL\Plan\ReplaceNodes;
 
 use function max;
 
@@ -34,6 +34,6 @@ public function apply(LogicalPlan $plan, FlowContext $context): LogicalPlan
             $limits[] = $limit;
         }
 
-        return $plan->transformUp(new ReplaceLeaf($leaf, $leaf->withLimit(max($limits))));
+        return $plan->transformUp(ReplaceNodes::one($leaf, $leaf->withLimit(max($limits))));
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushProjectionIntoExpand.php b/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushProjectionIntoExpand.php
index 4a32d1fd81..cf91544685 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushProjectionIntoExpand.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/Rule/PushProjectionIntoExpand.php
@@ -9,13 +9,10 @@
 use Flow\ETL\Optimizer\Rule;
 use Flow\ETL\Plan\LogicalPlan;
 use Flow\ETL\Plan\Node;
-use Flow\ETL\Plan\ReplaceLeaf;
+use Flow\ETL\Plan\ReplaceNodes;
 use Flow\ETL\Plan\RequiredColumns;
 use SplObjectStorage;
 
-use function arsort;
-use function spl_object_id;
-
 /**
  * Columns no consumer reads are not copied into the rows an expand emits (Spark: ColumnPruning setting
  * Generate.unrequiredChildIndex).
@@ -40,33 +37,15 @@ public function apply(LogicalPlan $plan, FlowContext $context): LogicalPlan
             }
         }
 
-        $depths = [];
-        $targets = [];
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
 
         foreach ($demands as $node) {
-            if ($demands[$node]->isAll()) {
-                continue;
-            }
-
-            $id = spl_object_id($node);
-            $targets[$id] = $node;
-            $depths[$id] = 0;
-
-            for ($below = $node; $below->children() !== []; $below = $below->children()[0]) {
-                $depths[$id]++;
+            if (!$demands[$node]->isAll()) {
+                $replacements[$node] = $node->withCarries($demands[$node]);
             }
         }
 
-        // TransformUp hands Rewrite::of() the node rebuilt over its new children, so a node whose descendant was
-        // replaced first would no longer be the target; the one farthest from the leaf goes first
-        arsort($depths);
-
-        foreach ($depths as $id => $_) {
-            $plan = $plan->transformUp(
-                new ReplaceLeaf($targets[$id], $targets[$id]->withCarries($demands[$targets[$id]])),
-            );
-        }
-
-        return $plan;
+        return $replacements->count() === 0 ? $plan : $plan->transformUp(new ReplaceNodes($replacements));
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Optimizer/TopNRewrite.php b/src/core/etl/src/Flow/ETL/Optimizer/TopNRewrite.php
index 2beb7e7720..af11e63585 100644
--- a/src/core/etl/src/Flow/ETL/Optimizer/TopNRewrite.php
+++ b/src/core/etl/src/Flow/ETL/Optimizer/TopNRewrite.php
@@ -15,19 +15,19 @@
  */
 final readonly class TopNRewrite implements Rewrite
 {
-    public function of(Node $node): Node
+    public function of(Node $original, Node $rebuilt): Node
     {
-        if (!$node instanceof Limit) {
-            return $node;
+        if (!$rebuilt instanceof Limit) {
+            return $rebuilt;
         }
 
-        $sort = $node->children()[0];
+        $sort = $rebuilt->children()[0];
 
         if (!$sort instanceof Sort) {
-            return $node;
+            return $rebuilt;
         }
 
         // a TopN past its memory limit falls back to the sort's own spilling path, so any limit is safe to rewrite
-        return new TopN($sort->children()[0], $sort->refs, $node->limit, $sort->algorithm);
+        return new TopN($sort->children()[0], $sort->refs, $rebuilt->limit, $sort->algorithm);
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Plan/Explain/Details.php b/src/core/etl/src/Flow/ETL/Plan/Explain/Details.php
index a6815e6530..a28edc17f3 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Explain/Details.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Explain/Details.php
@@ -5,6 +5,7 @@
 namespace Flow\ETL\Plan\Explain;
 
 use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Join\Comparison\Any;
 use Flow\ETL\Plan\Materialization;
 use Flow\ETL\Plan\Node;
@@ -80,7 +81,7 @@ public function labelled(Node $node): array
             $node instanceof Offset => ['Skip: ' . $node->offset],
             $node instanceof TopN => ['Top: ' . $node->limit],
             $node instanceof Rename => [sprintf('Rename: %s → %s', $node->from, $node->to)],
-            $node instanceof Select => ['Columns: ' . $this->columns($node->entries)],
+            $node instanceof Select => ['Keeps only: ' . $this->columns($node->entries)],
             $node instanceof Drop => ['Drops: ' . $this->columns($node->entries)],
             $node instanceof Distinct => [
                 'Distinct on: ' . ($node->entries === [] ? 'every column' : $this->columns($node->entries)),
@@ -206,15 +207,29 @@ public function read(Read $read): array
             $lines[] = 'Source: ' . $extractor->source()->uri();
         }
 
-        $limit = $read->limit();
+        return [...$lines, ...$this->scan($read->scan())];
+    }
+
+    /**
+     * What the plan pushed into a read, each conjunct the source applies on its own line.
+     *
+     * @return list<string>
+     */
+    public function scan(FileScan $scan): array
+    {
+        $lines = [];
 
-        if ($limit !== null) {
-            $lines[] = 'Limit: ' . $limit;
+        if ($scan->limit !== null) {
+            $lines[] = 'Limit: ' . $scan->limit;
         }
 
         // every file source reads only files unless a filter was pushed into it
-        if (!$read->pathFilter() instanceof OnlyFiles) {
-            $lines[] = 'Files: ' . $this->name($read->pathFilter());
+        if (!$scan->pathFilter instanceof OnlyFiles) {
+            $lines[] = 'Files: ' . $this->name($scan->pathFilter);
+        }
+
+        foreach ($scan->conjuncts as $conjunct) {
+            $lines[] = 'Filter: ' . $this->name($conjunct);
         }
 
         return $lines;
@@ -234,10 +249,10 @@ public function notes(Node $node): array
             $notes[] = 'Buffers all rows before passing them on';
         }
 
-        if ($redefines->unknown) {
-            $notes[] = 'Defines columns known only at run time';
-        } elseif ($redefines->names !== []) {
-            $notes[] = 'Defines columns: ' . implode(', ', $redefines->names);
+        if ($redefines->isUnknown()) {
+            $notes[] = 'Changes columns known only at run time';
+        } elseif (!$redefines->isAllBut() && $redefines->names !== []) {
+            $notes[] = 'Changes columns: ' . implode(', ', $redefines->names);
         }
 
         return $notes;
@@ -255,8 +270,10 @@ public function declarations(Node $node): string
             $node->materialization()->name,
         ];
 
-        if ($redefines->unknown) {
+        if ($redefines->isUnknown()) {
             $declarations[] = 'redefines unknown';
+        } elseif ($redefines->isAllBut()) {
+            $declarations[] = 'redefines all but ' . implode(', ', $redefines->names);
         } elseif ($redefines->names !== []) {
             $declarations[] = 'redefines ' . implode(', ', $redefines->names);
         }
diff --git a/src/core/etl/src/Flow/ETL/Plan/Explain/PhysicalOutline.php b/src/core/etl/src/Flow/ETL/Plan/Explain/PhysicalOutline.php
index cea5a9af82..3c893d8e6e 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Explain/PhysicalOutline.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Explain/PhysicalOutline.php
@@ -9,8 +9,8 @@
 use Flow\ETL\Executor\Pipeline;
 use Flow\ETL\Processor\HashJoinProcessor;
 use Flow\ETL\Transformer\CrossJoinRowsTransformer;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 
+use function array_map;
 use function implode;
 
 final readonly class PhysicalOutline
@@ -94,18 +94,7 @@ public function joined(PhysicalPlan $right): Entry
      */
     public function source(Pipeline $pipeline): array
     {
-        $lines = [];
-        $limit = $pipeline->limit();
-
-        if ($limit !== null) {
-            $lines[] = '   Limit: ' . $limit;
-        }
-
-        if (!$pipeline->pathFilter() instanceof OnlyFiles) {
-            $lines[] = '   Files: ' . $this->details->name($pipeline->pathFilter());
-        }
-
-        return $lines;
+        return array_map(static fn(string $line): string => '   ' . $line, $this->details->scan($pipeline->scan()));
     }
 
     /**
diff --git a/src/core/etl/src/Flow/ETL/Plan/Node.php b/src/core/etl/src/Flow/ETL/Plan/Node.php
index 9b2e4d0129..e9d0a3c87d 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Node.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Node.php
@@ -54,7 +54,7 @@ public function transparency(): Transparency;
     public function materialization(): Materialization;
 
     /**
-     * Columns this node introduces or renames on its output. A predicate that references one of them means a
+     * Columns this node introduces, renames or removes on its output. A predicate that references one of them means a
      * different column below this node, so it cannot be pushed past it. Answered from what the node holds,
      * never from a class list.
      */
diff --git a/src/core/etl/src/Flow/ETL/Plan/Node/Drop.php b/src/core/etl/src/Flow/ETL/Plan/Node/Drop.php
index 0b3360c587..e35cac6df4 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Node/Drop.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Node/Drop.php
@@ -10,6 +10,7 @@
 use Flow\ETL\Plan\RowCount;
 use Flow\ETL\Plan\Transparency;
 use Flow\ETL\Row\Reference;
+use Flow\ETL\Row\References;
 
 final readonly class Drop implements Node
 {
@@ -51,6 +52,6 @@ public function materialization(): Materialization
 
     public function redefines(): Redefined
     {
-        return Redefined::none();
+        return Redefined::names(...References::init(...$this->entries)->names());
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Plan/Node/Read.php b/src/core/etl/src/Flow/ETL/Plan/Node/Read.php
index f94adb446e..5a3de95d3c 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Node/Read.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Node/Read.php
@@ -7,6 +7,9 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\Exception\SchemaNotDerivableException;
 use Flow\ETL\Extractor;
+use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
+use Flow\ETL\Function\ScalarFunction;
 use Flow\ETL\Plan\Materialization;
 use Flow\ETL\Plan\Node;
 use Flow\ETL\Plan\Redefined;
@@ -14,22 +17,17 @@
 use Flow\ETL\Plan\Transparency;
 use Flow\ETL\Schema;
 use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\Filters;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
-
-use function min;
 
 final readonly class Read implements Node
 {
     /**
      * @param Extractor $extractor the instance the user handed to read(); the planner never mutates or copies it
-     * @param null|int<1, max> $limit the pushed limit, handed to Extractor::extract() when the plan runs
-     * @param Filter $pathFilter the pushed partition filter, handed to FileExtractor::extract() when the plan runs
+     * @param FileScan $scan what the plan pushed into the read, handed to FileExtractor::scan() when the plan
+     *                       runs; a non-file extractor receives only its limit
      */
     public function __construct(
         private Extractor $extractor,
-        private ?int $limit = null,
-        private Filter $pathFilter = new OnlyFiles(),
+        private FileScan $scan = new FileScan(),
     ) {}
 
     public function extractor(): Extractor
@@ -37,28 +35,17 @@ public function extractor(): Extractor
         return $this->extractor;
     }
 
-    /**
-     * @return null|int<1, max>
-     */
-    public function limit(): ?int
+    public function scan(): FileScan
     {
-        return $this->limit;
+        return $this->scan;
     }
 
-    public function pathFilter(): Filter
-    {
-        return $this->pathFilter;
-    }
-
-    public function withPathFilter(Filter $filter): self
+    /**
+     * @throws InvalidArgumentException when the extractor is no FileExtractor, which has nowhere to apply it
+     */
+    public function withFilter(ScalarFunction $filter): self
     {
-        return new self(
-            $this->extractor,
-            $this->limit,
-            $this->pathFilter instanceof Filters
-                ? $this->pathFilter->add($filter)
-                : new Filters($this->pathFilter, $filter),
-        );
+        return new self($this->fileExtractor(), $this->scan->withFilter($filter));
     }
 
     /**
@@ -68,15 +55,15 @@ public function withPathFilter(Filter $filter): self
      */
     public function withLimit(int $limit): self
     {
-        if ($limit <= 0) {
-            throw new InvalidArgumentException('Limit must be greater than 0');
-        }
-
-        return new self(
-            $this->extractor,
-            $this->limit === null ? $limit : min($this->limit, $limit),
-            $this->pathFilter,
-        );
+        return new self($this->extractor, $this->scan->withLimit($limit));
+    }
+
+    /**
+     * @throws InvalidArgumentException when the extractor is no FileExtractor, which has nowhere to apply it
+     */
+    public function withPathFilter(Filter $filter): self
+    {
+        return new self($this->fileExtractor(), $this->scan->withPathFilter($filter));
     }
 
     /**
@@ -119,4 +106,13 @@ public function redefines(): Redefined
     {
         return Redefined::none();
     }
+
+    private function fileExtractor(): FileExtractor
+    {
+        return $this->extractor instanceof FileExtractor
+            ? $this->extractor
+            : throw new InvalidArgumentException(
+                'Only a FileExtractor reads a pushed filter, ' . $this->extractor::class . ' does not',
+            );
+    }
 }
diff --git a/src/core/etl/src/Flow/ETL/Plan/Node/Rename.php b/src/core/etl/src/Flow/ETL/Plan/Node/Rename.php
index c3f29e3ee8..c7806345eb 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Node/Rename.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Node/Rename.php
@@ -48,6 +48,6 @@ public function materialization(): Materialization
 
     public function redefines(): Redefined
     {
-        return Redefined::alias($this->to, $this->from);
+        return Redefined::rename($this->from, $this->to);
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Plan/Node/Select.php b/src/core/etl/src/Flow/ETL/Plan/Node/Select.php
index 0221ceca07..c651bf7a17 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Node/Select.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Node/Select.php
@@ -10,6 +10,7 @@
 use Flow\ETL\Plan\RowCount;
 use Flow\ETL\Plan\Transparency;
 use Flow\ETL\Row\Reference;
+use Flow\ETL\Row\References;
 
 final readonly class Select implements Node
 {
@@ -51,6 +52,6 @@ public function materialization(): Materialization
 
     public function redefines(): Redefined
     {
-        return Redefined::none();
+        return Redefined::allBut(...References::init(...$this->entries)->names());
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Plan/Redefined.php b/src/core/etl/src/Flow/ETL/Plan/Redefined.php
index b64220a352..4eafeeacb7 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Redefined.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Redefined.php
@@ -15,19 +15,27 @@
      * @param array<string, string> $aliases a redefined name => the column below the node it only renames
      */
     private function __construct(
-        public bool $unknown,
+        private Redefinition $redefinition,
         public array $names,
         private array $aliases,
     ) {}
 
     public static function none(): self
     {
-        return new self(false, [], []);
+        return new self(Redefinition::names, [], []);
     }
 
     public static function names(string ...$names): self
     {
-        return new self(false, array_values($names), []);
+        return new self(Redefinition::names, array_values($names), []);
+    }
+
+    /**
+     * The node keeps only $kept (Select): every other column is gone above it.
+     */
+    public static function allBut(string ...$kept): self
+    {
+        return new self(Redefinition::allBut, array_values($kept), []);
     }
 
     /**
@@ -36,7 +44,15 @@ public static function names(string ...$names): self
      */
     public static function alias(string $name, string $below): self
     {
-        return new self(false, [$name], [$name => $below]);
+        return new self(Redefinition::names, [$name], [$name => $below]);
+    }
+
+    /**
+     * $to holds exactly the values of $from, which is gone above the node.
+     */
+    public static function rename(string $from, string $to): self
+    {
+        return new self(Redefinition::names, [$to, $from], [$to => $from]);
     }
 
     /**
@@ -44,12 +60,26 @@ public static function alias(string $name, string $below): self
      */
     public static function unknown(): self
     {
-        return new self(true, [], []);
+        return new self(Redefinition::unknown, [], []);
     }
 
     public function defines(string $name): bool
     {
-        return $this->unknown || in_array($name, $this->names, true);
+        return match ($this->redefinition) {
+            Redefinition::unknown => true,
+            Redefinition::allBut => !in_array($name, $this->names, true),
+            Redefinition::names => in_array($name, $this->names, true),
+        };
+    }
+
+    public function isAllBut(): bool
+    {
+        return $this->redefinition === Redefinition::allBut;
+    }
+
+    public function isUnknown(): bool
+    {
+        return $this->redefinition === Redefinition::unknown;
     }
 
     /**
diff --git a/src/core/etl/src/Flow/ETL/Plan/Redefinition.php b/src/core/etl/src/Flow/ETL/Plan/Redefinition.php
new file mode 100644
index 0000000000..51dedd4f57
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Plan/Redefinition.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Plan;
+
+enum Redefinition
+{
+    case names;
+    case allBut;
+    case unknown;
+}
diff --git a/src/core/etl/src/Flow/ETL/Plan/ReplaceLeaf.php b/src/core/etl/src/Flow/ETL/Plan/ReplaceLeaf.php
deleted file mode 100644
index 36f49a146d..0000000000
--- a/src/core/etl/src/Flow/ETL/Plan/ReplaceLeaf.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Flow\ETL\Plan;
-
-final readonly class ReplaceLeaf implements Rewrite
-{
-    public function __construct(
-        private Node $target,
-        private Node $replacement,
-    ) {}
-
-    public function of(Node $node): Node
-    {
-        return $node === $this->target ? $this->replacement : $node;
-    }
-}
diff --git a/src/core/etl/src/Flow/ETL/Plan/ReplaceNodes.php b/src/core/etl/src/Flow/ETL/Plan/ReplaceNodes.php
new file mode 100644
index 0000000000..2074e2e685
--- /dev/null
+++ b/src/core/etl/src/Flow/ETL/Plan/ReplaceNodes.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Plan;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use SplObjectStorage;
+
+use function count;
+use function in_array;
+
+final readonly class ReplaceNodes implements Rewrite
+{
+    /**
+     * Targets are found by the identity they have before the rewrite.
+     *
+     * @param SplObjectStorage<Node, Node> $replacements target => replacement, which takes the target's rewritten
+     *                                                   children
+     * @param list<Node> $removals nodes of one child, each giving way to its rewritten child
+     */
+    public function __construct(
+        private SplObjectStorage $replacements,
+        private array $removals = [],
+    ) {
+        foreach ($removals as $removal) {
+            if ($replacements->offsetExists($removal)) {
+                throw new InvalidArgumentException(
+                    'A node is either replaced or removed, ' . $removal::class . ' is both',
+                );
+            }
+        }
+    }
+
+    public static function one(Node $target, Node $replacement): self
+    {
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
+        $replacements[$target] = $replacement;
+
+        return new self($replacements);
+    }
+
+    public function of(Node $original, Node $rebuilt): Node
+    {
+        if (in_array($original, $this->removals, true)) {
+            return count($rebuilt->children()) === 1
+                ? $rebuilt->children()[0]
+                : throw new InvalidArgumentException(
+                    'Only a node of one child gives way to it, ' . $original::class . ' has '
+                        . count($rebuilt->children()),
+                );
+        }
+
+        return $this->replacements->offsetExists($original)
+            ? $this->replacements[$original]->withChildren($rebuilt->children())
+            : $rebuilt;
+    }
+}
diff --git a/src/core/etl/src/Flow/ETL/Plan/Rewrite.php b/src/core/etl/src/Flow/ETL/Plan/Rewrite.php
index 5b60893224..b466330d12 100644
--- a/src/core/etl/src/Flow/ETL/Plan/Rewrite.php
+++ b/src/core/etl/src/Flow/ETL/Plan/Rewrite.php
@@ -7,10 +7,11 @@
 interface Rewrite
 {
     /**
-     * The replacement for this node, or the node itself when nothing changes.
+     * The replacement for $original, given as $rebuilt over its rewritten children; $rebuilt itself when nothing
+     * changes.
      *
      * Apply it to a plan through LogicalPlan::transformUp(): its memo rewrites a node every consumer shares
      * exactly once, so the shared prefix stays shared. It never reaches into a join's right side.
      */
-    public function of(Node $node): Node;
+    public function of(Node $original, Node $rebuilt): Node;
 }
diff --git a/src/core/etl/src/Flow/ETL/Plan/TransformUp.php b/src/core/etl/src/Flow/ETL/Plan/TransformUp.php
index 2a674b80c7..f3d2db87ca 100644
--- a/src/core/etl/src/Flow/ETL/Plan/TransformUp.php
+++ b/src/core/etl/src/Flow/ETL/Plan/TransformUp.php
@@ -41,6 +41,6 @@ public function of(Node $node, Rewrite $rewrite): Node
             $children[$i] = $this->of($children[$i], $rewrite);
         }
 
-        return $this->memo[$node] = $rewrite->of($node->withChildren($children));
+        return $this->memo[$node] = $rewrite->of($node, $node->withChildren($children));
     }
 }
diff --git a/src/core/etl/src/Flow/ETL/Planner/PipelineSplit.php b/src/core/etl/src/Flow/ETL/Planner/PipelineSplit.php
index fb5645b886..fcd00eb8d8 100644
--- a/src/core/etl/src/Flow/ETL/Planner/PipelineSplit.php
+++ b/src/core/etl/src/Flow/ETL/Planner/PipelineSplit.php
@@ -11,11 +11,11 @@
 use Flow\ETL\Executor\Raw;
 use Flow\ETL\Executor\Segments;
 use Flow\ETL\Executor\SourceRows;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\FlowContext;
 use Flow\ETL\Plan\LogicalPlan;
 use Flow\ETL\Plan\Materialization;
 use Flow\ETL\Plan\Node;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use SplObjectStorage;
 
 use function array_reverse;
@@ -59,8 +59,7 @@ public function of(
         $read = $logical->source();
         $input = null;
         $segments = new Segments($read->extractor());
-        $limit = $read->limit();
-        $pathFilter = $read->pathFilter();
+        $scan = $read->scan();
 
         $attachment = new SinkAttachment($planned, $context);
         $remembered = $attachment->attach($logical->sinksOnSpine(), $onSpine);
@@ -76,15 +75,14 @@ public function of(
             }
 
             if ($node->materialization() === Materialization::blocking && $node !== $top) {
-                $input = new Pipeline($id++, $segments, $context, $input, $limit, $pathFilter, $sources);
+                $input = new Pipeline($id++, $segments, $context, $input, $scan, $sources);
                 $segments = new Segments();
-                $limit = null;
-                $pathFilter = new OnlyFiles();
+                $scan = new FileScan();
                 $sources = null;
             }
         }
 
-        $pipeline = new Pipeline($id, $segments, $context, $input, $limit, $pathFilter, $sources);
+        $pipeline = new Pipeline($id, $segments, $context, $input, $scan, $sources);
         $refusal = $planned->refusal();
 
         return $refusal === null
diff --git a/src/core/etl/src/Flow/ETL/Schema/Definition/StringDefinition.php b/src/core/etl/src/Flow/ETL/Schema/Definition/StringDefinition.php
index e17bb917cd..8a2e04dce3 100644
--- a/src/core/etl/src/Flow/ETL/Schema/Definition/StringDefinition.php
+++ b/src/core/etl/src/Flow/ETL/Schema/Definition/StringDefinition.php
@@ -29,14 +29,18 @@
      */
     private Type $type;
 
+    /**
+     * @param null|Type<string> $type
+     */
     public function __construct(
         string|Reference $ref,
         private bool $nullable = false,
         ?Metadata $metadata = null,
+        ?Type $type = null,
     ) {
         $this->ref = UnresolvedReference::init($ref);
         $this->metadata = $metadata ?? Metadata::empty();
-        $this->type = type_string();
+        $this->type = $type ?? type_string();
     }
 
     /**
@@ -44,7 +48,7 @@ public function __construct(
      */
     public function addMetadata(string $key, int|string|bool|float|array $value): static
     {
-        return new self($this->ref, $this->nullable, $this->metadata->add($key, $value));
+        return new self($this->ref, $this->nullable, $this->metadata->add($key, $value), $this->type);
     }
 
     public function entry(): Reference
@@ -85,7 +89,7 @@ public function isSame(Definition $definition): bool
 
     public function makeNullable(bool $nullable = true): static
     {
-        return new self($this->ref, $nullable, $this->metadata);
+        return new self($this->ref, $nullable, $this->metadata, $this->type);
     }
 
     public function matches(mixed $value): bool
@@ -111,6 +115,7 @@ public function merge(Definition $definition): Definition
             $this->ref,
             $this->nullable || $definition->isNullable(),
             $this->metadata->merge($definition->metadata()),
+            type_equals($this->type, $definition->type()) ? $this->type : type_string(),
         );
     }
 
@@ -134,12 +139,12 @@ public function normalize(): array
 
     public function rename(string $newName): static
     {
-        return new self($newName, $this->nullable, $this->metadata);
+        return new self($newName, $this->nullable, $this->metadata, $this->type);
     }
 
     public function setMetadata(Metadata $metadata): static
     {
-        return new self($this->ref, $this->nullable, $metadata);
+        return new self($this->ref, $this->nullable, $metadata, $this->type);
     }
 
     public function type(): Type
diff --git a/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPFormatter/TypeFormatter.php b/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPFormatter/TypeFormatter.php
index 3be4378cc4..2026001445 100644
--- a/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPFormatter/TypeFormatter.php
+++ b/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPFormatter/TypeFormatter.php
@@ -12,6 +12,7 @@
 use Flow\Types\Type\Logical\JsonType;
 use Flow\Types\Type\Logical\ListType;
 use Flow\Types\Type\Logical\MapType;
+use Flow\Types\Type\Logical\NumericStringType;
 use Flow\Types\Type\Logical\OptionalType;
 use Flow\Types\Type\Logical\StructureType;
 use Flow\Types\Type\Logical\TimeType;
@@ -109,6 +110,7 @@ private function formatSimpleType(Type $type, bool $nullable): string
         $reflection = match ($type::class) {
             ArrayType::class => new ReflectionFunction('\\Flow\\Types\\DSL\\type_array'),
             StringType::class => new ReflectionFunction('\\Flow\\Types\\DSL\\type_string'),
+            NumericStringType::class => new ReflectionFunction('\\Flow\\Types\\DSL\\type_numeric_string'),
             IntegerType::class => new ReflectionFunction('\\Flow\\Types\\DSL\\type_integer'),
             BooleanType::class => new ReflectionFunction('\\Flow\\Types\\DSL\\type_boolean'),
             FloatType::class => new ReflectionFunction('\\Flow\\Types\\DSL\\type_float'),
diff --git a/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPSchemaFormatter.php b/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPSchemaFormatter.php
index ee33dae1eb..2ba94537fd 100644
--- a/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPSchemaFormatter.php
+++ b/src/core/etl/src/Flow/ETL/Schema/Formatter/PHPSchemaFormatter.php
@@ -19,6 +19,7 @@
 use Flow\Types\Type\Logical\JsonType;
 use Flow\Types\Type\Logical\ListType;
 use Flow\Types\Type\Logical\MapType;
+use Flow\Types\Type\Logical\NumericStringType;
 use Flow\Types\Type\Logical\StructureType;
 use Flow\Types\Type\Logical\TimeType;
 use Flow\Types\Type\Logical\TimeZoneType;
@@ -152,6 +153,7 @@ private function formatSchema(Schema $schema, int $level = 1): string
                 DateTimeType::class => $this->dateTimeType($definition),
                 FloatType::class => $this->floatType($definition),
                 EnumType::class => $this->enumType($definition),
+                NumericStringType::class => $this->numericStringType($definition),
                 ListType::class => $this->listType($definition),
                 MapType::class => $this->mapType($definition),
                 StructureType::class => $this->structureType($definition),
@@ -201,6 +203,23 @@ private function mapType(Definition $definition): string
         );
     }
 
+    /**
+     * @param Definition<mixed> $definition
+     */
+    private function numericStringType(Definition $definition): string
+    {
+        $reflection = new ReflectionFunction("\Flow\ETL\DSL\\definition_from_type");
+
+        return sprintf(
+            '\%s("%s", type: %s, nullable: %s, metadata: %s)',
+            $reflection->getName(),
+            $definition->entry()->name(),
+            $this->typeFormatter->format($definition->type()),
+            $definition->isNullable() ? 'true' : 'false',
+            $this->formatMetadata($definition->metadata()),
+        );
+    }
+
     /**
      * @param Definition<mixed> $definition
      */
diff --git a/src/core/etl/src/Flow/ETL/Transformer/ScalarFunctionFilterTransformer.php b/src/core/etl/src/Flow/ETL/Transformer/ScalarFunctionFilterTransformer.php
index c7a9b6ef23..36772860c5 100644
--- a/src/core/etl/src/Flow/ETL/Transformer/ScalarFunctionFilterTransformer.php
+++ b/src/core/etl/src/Flow/ETL/Transformer/ScalarFunctionFilterTransformer.php
@@ -8,33 +8,29 @@
 use Flow\ETL\Config\Telemetry\TelemetryAttributes;
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\FlowContext;
-use Flow\ETL\Function\ExpandingFunctions;
-use Flow\ETL\Function\ReferenceResolver;
+use Flow\ETL\Function\Evaluation\Filter;
 use Flow\ETL\Function\ScalarFunction;
 use Flow\ETL\Rows;
 use Flow\ETL\Schema;
 use Flow\ETL\Transformer;
 use Throwable;
 
-use function array_keys;
-use function Flow\Types\DSL\type_bare;
-use function Flow\Types\DSL\type_boolean;
-use function Flow\Types\DSL\type_equals;
-use function sprintf;
-
 final readonly class ScalarFunctionFilterTransformer implements Transformer
 {
     /**
-     * @param null|ScalarFunction $resolved the predicate resolved against the bound schema; only bind() sets it
+     * @param null|Filter $filter the predicate bound to the input schema; only bind() sets it
      */
     public function __construct(
         public ScalarFunction $function,
-        private ?ScalarFunction $resolved = null,
+        private ?Filter $filter = null,
     ) {}
 
+    /**
+     * @throws InvalidArgumentException
+     */
     public function bind(Schema $input): BoundStep
     {
-        return new BoundStep(new self($this->function, $this->resolve($input)), $input);
+        return new BoundStep(new self($this->function, Filter::bind($input, $this->function)), $input);
     }
 
     public function transform(Rows $rows, FlowContext $context): Rows
@@ -42,8 +38,7 @@ public function transform(Rows $rows, FlowContext $context): Rows
         $context->telemetry()->transformationStarted($this);
 
         try {
-            $function = $this->resolved ?? $this->resolve($rows->schema());
-            $result = $rows->gather(array_keys($function->eval($rows, $context)->physicals(), true, true));
+            $result = ($this->filter ?? Filter::bind($rows->schema(), $this->function))->filter($rows, $context);
 
             $context->telemetry()->transformationCompleted($this, [
                 TelemetryAttributes::ATTR_TRANSFORMATION_INPUT_ROWS => $rows->count(),
@@ -57,28 +52,4 @@ public function transform(Rows $rows, FlowContext $context): Rows
             throw $e;
         }
     }
-
-    /**
-     * @throws InvalidArgumentException
-     */
-    private function resolve(Schema $input): ScalarFunction
-    {
-        $resolver = new ReferenceResolver();
-        $resolved = $resolver->resolve($this->function, $input);
-        $resolver->assertResolved($resolved, $input);
-        (new ExpandingFunctions())->refuse($resolved, 'filter');
-
-        // type_bare() keeps the gate blind to nullability - a null-propagating predicate declares
-        // ?boolean, and (bool) null === false is how a NULL row is dropped.
-        if (!type_equals(type_bare($resolved->returns()), type_boolean())) {
-            throw new InvalidArgumentException(sprintf(
-                'filter() requires a predicate returning boolean, "%s" returns "%s". '
-                . 'Use an explicit comparison, e.g. ->notEquals(lit(0)).',
-                $resolved::class,
-                $resolved->returns()->toString(),
-            ));
-        }
-
-        return $resolved;
-    }
 }
diff --git a/src/core/etl/src/Flow/Floe/FloeExtractor.php b/src/core/etl/src/Flow/Floe/FloeExtractor.php
index 1aa43bd420..d65e2f3ffb 100644
--- a/src/core/etl/src/Flow/Floe/FloeExtractor.php
+++ b/src/core/etl/src/Flow/Floe/FloeExtractor.php
@@ -13,8 +13,10 @@
 use Flow\ETL\Extractor\File\FileExtractor;
 use Flow\ETL\Extractor\File\FileReading;
 use Flow\ETL\Extractor\File\FileReadLoop;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\File\MetadataColumnsExtractor;
 use Flow\ETL\Extractor\File\ReadWindow;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Extractor\Statistics;
@@ -24,8 +26,6 @@
 use Flow\Filesystem\Filesystem;
 use Flow\Filesystem\Local\NativeLocalFilesystem;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Flow\Floe\Codec\NoopCodec;
 use Generator;
 
@@ -42,6 +42,7 @@ final class FloeExtractor implements
 {
     use Batches;
     use FileReading;
+    use Scanning;
 
     private ?int $offset = null;
 
@@ -78,12 +79,12 @@ public function isRepeatable(): bool
     /**
      * @return Generator<int, Rows, Signal|null, void>
      */
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
         $fileColumns = $this->fileColumns($this->filesystem, $this->path);
 
-        yield from (new FileReadLoop($fileColumns, $this->schema()))->read(
-            iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $pathFilter), false),
+        yield from (new FileReadLoop($fileColumns, $this->schema(), $scan->conjuncts))->read(
+            iterator_to_array($this->sourceFiles($this->filesystem, $this->path, $scan->pathFilter), false),
             new FloeFileBatches(
                 $this->filesystem,
                 $this->codec,
@@ -94,8 +95,8 @@ public function extract(FlowContext $context, ?int $limit = null, Filter $pathFi
                     : new DerivedSchema($this->derivedSchema($this->files(), $this->unionByName), $this->derivedFrom),
             ),
             $this->batchSize(),
-            $context->backend(),
-            new ReadWindow($this->offset ?? 0, $limit),
+            $context,
+            new ReadWindow($this->offset ?? 0, $scan->limit),
         );
     }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Context/ExtractedRows.php b/src/core/etl/tests/Flow/ETL/Tests/Context/ExtractedRows.php
index 836b22c590..2a02c79b1e 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Context/ExtractedRows.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Context/ExtractedRows.php
@@ -5,11 +5,10 @@
 namespace Flow\ETL\Tests\Context;
 
 use Flow\ETL\Extractor;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\FlowContext;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\FlowTestCase;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\rows;
@@ -17,19 +16,12 @@
 
 final class ExtractedRows
 {
-    /**
-     * @param null|int<1, max> $limit
-     */
-    public static function of(
-        Extractor $extractor,
-        ?FlowContext $context = null,
-        ?int $limit = null,
-        Filter $pathFilter = new OnlyFiles(),
-    ): Rows {
+    public static function of(Extractor $extractor, ?FlowContext $context = null, FileScan $scan = new FileScan()): Rows
+    {
         $context ??= flow_context();
         $extracted = null;
 
-        foreach (FlowTestCase::extracted($extractor, $context, $limit, $pathFilter) as $batch) {
+        foreach (FlowTestCase::extracted($extractor, $context, $scan) as $batch) {
             $extracted = $extracted === null ? $batch : $extracted->concat($context->backend(), $batch);
         }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Double/RecordingFileExtractor.php b/src/core/etl/tests/Flow/ETL/Tests/Double/RecordingFileExtractor.php
index 5e9cbe6011..f66fd572be 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Double/RecordingFileExtractor.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Double/RecordingFileExtractor.php
@@ -5,33 +5,31 @@
 namespace Flow\ETL\Tests\Double;
 
 use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
+use Flow\ETL\Extractor\File\Scanning;
 use Flow\ETL\Extractor\Statistics;
 use Flow\ETL\FlowContext;
+use Flow\ETL\Function\Evaluation\Filter;
 use Flow\ETL\Rows;
 use Flow\ETL\Schema;
 use Flow\Filesystem\Path;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 
 use function array_values;
 use function Flow\Filesystem\DSL\path;
 
 /**
- * A file source that records the limit and path filter of every read, so a test can prove what the planner
- * pushed reached the read - and that the instance itself was left alone.
+ * A file source that records the scan of every read, so a test can prove what the planner pushed reached the
+ * read - and that the instance itself was left alone. It returns only the rows matching the scan's filter.
  */
 final class RecordingFileExtractor implements FileExtractor
 {
-    /**
-     * @var list<null|int>
-     */
-    public array $limits = [];
+    use Scanning;
 
     /**
-     * @var list<Filter>
+     * @var list<FileScan>
      */
-    public array $pathFilters = [];
+    public array $scans = [];
 
     /**
      * @var list<Rows>
@@ -48,13 +46,13 @@ public function __construct(
         $this->partitions = new Schema();
     }
 
-    public function extract(FlowContext $context, ?int $limit = null, Filter $pathFilter = new OnlyFiles()): Generator
+    public function scan(FlowContext $context, FileScan $scan): Generator
     {
-        $this->limits[] = $limit;
-        $this->pathFilters[] = $pathFilter;
+        $this->scans[] = $scan;
+        $filter = Filter::bind($this->schema, ...$scan->conjuncts);
 
         foreach ($this->batches as $rows) {
-            yield $rows;
+            yield $filter->filter($rows, $context);
         }
     }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Double/RenameSelectRewrite.php b/src/core/etl/tests/Flow/ETL/Tests/Double/RenameSelectRewrite.php
index 223e428f12..5bc42d6fbe 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Double/RenameSelectRewrite.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Double/RenameSelectRewrite.php
@@ -11,8 +11,8 @@
 
 final readonly class RenameSelectRewrite implements Rewrite
 {
-    public function of(Node $node): Node
+    public function of(Node $original, Node $rebuilt): Node
     {
-        return $node instanceof Select ? NodeMother::select($node->children()[0], 'name') : $node;
+        return $rebuilt instanceof Select ? NodeMother::select($rebuilt->children()[0], 'name') : $rebuilt;
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Double/SpineCopyingRule.php b/src/core/etl/tests/Flow/ETL/Tests/Double/SpineCopyingRule.php
index 6a243df2cd..614e6f6803 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Double/SpineCopyingRule.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Double/SpineCopyingRule.php
@@ -24,8 +24,8 @@ public function apply(LogicalPlan $plan, FlowContext $context): LogicalPlan
         return new LogicalPlan((new TransformUp())->of($plan->root, $this));
     }
 
-    public function of(Node $node): Node
+    public function of(Node $original, Node $rebuilt): Node
     {
-        return $node instanceof Read ? new Read($node->extractor(), $node->limit(), $node->pathFilter()) : $node;
+        return $rebuilt instanceof Read ? new Read($rebuilt->extractor(), $rebuilt->scan()) : $rebuilt;
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/FlowTestCase.php b/src/core/etl/tests/Flow/ETL/Tests/FlowTestCase.php
index a62327205e..5702d6f613 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/FlowTestCase.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/FlowTestCase.php
@@ -8,12 +8,11 @@
 use Flow\ETL\Extractor;
 use Flow\ETL\Extractor\BatchableExtractor;
 use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\RewindableExtractor;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\FlowContext;
 use Flow\ETL\Rows;
-use Flow\Filesystem\Path\Filter;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Generator;
 use PHPUnit\Framework\TestCase;
 use RuntimeException;
@@ -110,20 +109,18 @@ final public static function assertExtractorHonoursMaximum(
 
     /**
      * @param array<array-key, mixed> $expectedArray
-     * @param null|int<1, max> $limit
      */
     final public static function assertExtractedRowsAsArrayEquals(
         array $expectedArray,
         Extractor $extractor,
         ?FlowContext $flowContext = null,
         string $message = '',
-        ?int $limit = null,
-        Filter $pathFilter = new OnlyFiles(),
+        FileScan $scan = new FileScan(),
     ): void {
         $flowContext ??= flow_context();
         $extractedRows = rows(schema());
 
-        foreach (self::extracted($extractor, $flowContext, $limit, $pathFilter) as $nextRows) {
+        foreach (self::extracted($extractor, $flowContext, $scan) as $nextRows) {
             $extractedRows = $extractedRows->isEmpty()
                 ? $nextRows
                 : $extractedRows->concat(new PhpBackend(), $nextRows);
@@ -132,42 +129,34 @@ final public static function assertExtractedRowsAsArrayEquals(
         static::assertEquals($expectedArray, $extractedRows->toArray(), $message);
     }
 
-    /**
-     * @param null|int<1, max> $limit
-     */
     final public static function assertExtractedRowsCount(
         int $expectedCount,
         Extractor $extractor,
         ?FlowContext $flowContext = null,
         string $message = '',
-        ?int $limit = null,
-        Filter $pathFilter = new OnlyFiles(),
+        FileScan $scan = new FileScan(),
     ): void {
         $flowContext ??= flow_context();
         $totalRows = 0;
 
-        foreach (self::extracted($extractor, $flowContext, $limit, $pathFilter) as $rows) {
+        foreach (self::extracted($extractor, $flowContext, $scan) as $rows) {
             $totalRows += $rows->count();
         }
 
         static::assertSame($expectedCount, $totalRows, $message);
     }
 
-    /**
-     * @param null|int<1, max> $limit
-     */
     final public static function assertExtractedRowsEquals(
         Rows $expectedRows,
         Extractor $extractor,
         ?FlowContext $flowContext = null,
         string $message = '',
-        ?int $limit = null,
-        Filter $pathFilter = new OnlyFiles(),
+        FileScan $scan = new FileScan(),
     ): void {
         $flowContext ??= flow_context();
         $extractedRows = rows(schema());
 
-        foreach (self::extracted($extractor, $flowContext, $limit, $pathFilter) as $nextRows) {
+        foreach (self::extracted($extractor, $flowContext, $scan) as $nextRows) {
             $extractedRows = $extractedRows->isEmpty()
                 ? $nextRows
                 : $extractedRows->concat(new PhpBackend(), $nextRows);
@@ -177,19 +166,13 @@ final public static function assertExtractedRowsEquals(
     }
 
     /**
-     * @param null|int<1, max> $limit
-     *
      * @return Generator<int, Rows>
      */
-    final public static function extracted(
-        Extractor $extractor,
-        FlowContext $context,
-        ?int $limit,
-        Filter $pathFilter,
-    ): Generator {
+    final public static function extracted(Extractor $extractor, FlowContext $context, FileScan $scan): Generator
+    {
         return $extractor instanceof FileExtractor
-            ? $extractor->extract($context, $limit, $pathFilter)
-            : $extractor->extract($context, $limit);
+            ? $extractor->scan($context, $scan)
+            : $extractor->extract($context, $scan->limit);
     }
 
     public function repositoryRoot(): string
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/AnalyzeTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/AnalyzeTest.php
index 9b149c6ff1..3cfd0fedfc 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/AnalyzeTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/AnalyzeTest.php
@@ -18,12 +18,17 @@
 use Flow\ETL\Tests\Double\InlineLoader;
 use Flow\ETL\Tests\FlowIntegrationTestCase;
 use Flow\ETL\Tests\Mother\MarketRowsMother;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
 
+use function Flow\ETL\Adapter\Parquet\from_parquet;
+use function Flow\ETL\Adapter\Parquet\to_parquet;
 use function Flow\ETL\Adapter\Text\from_text;
 use function Flow\ETL\DSL\analyze;
 use function Flow\ETL\DSL\config_builder;
 use function Flow\ETL\DSL\df;
 use function Flow\ETL\DSL\from_array;
+use function Flow\ETL\DSL\from_sequence_number;
 use function Flow\ETL\DSL\infer_schema;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\join_on;
@@ -31,6 +36,8 @@
 use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
+use function Flow\Filesystem\DSL\memory_filesystem;
+use function Flow\Filesystem\DSL\path;
 
 final class AnalyzeTest extends FlowIntegrationTestCase
 {
@@ -216,6 +223,35 @@ public function test_a_source_read_under_a_pushed_limit_reports_no_rows_error():
         static::assertNull($sources[0]->rowsError());
     }
 
+    public function test_a_source_read_under_a_pushed_filter_reports_no_rows_error(): void
+    {
+        $memory = memory_filesystem();
+        df()
+            ->read(from_sequence_number('id', 1, 3000))
+            ->write(to_parquet(
+                path('memory://analyze/ids.parquet'),
+                Options::default()->set(Option::ROW_GROUP_SIZE_BYTES, 1)->set(
+                    Option::ROW_GROUP_SIZE_CHECK_INTERVAL,
+                    1000,
+                ),
+                filesystem: $memory,
+            ))
+            ->run();
+
+        $report = df()
+            ->read(from_parquet(path('memory://analyze/ids.parquet'), filesystem: $memory))
+            ->filter(ref('id')->greaterThan(lit(2500)))
+            ->run(analyze: analyze()->withSourceStatistics());
+
+        static::assertNotNull($report);
+        $sources = $report->sources();
+        static::assertNotNull($sources);
+        static::assertCount(1, $sources);
+        static::assertFalse($sources[0]->complete);
+        static::assertLessThan(3000, $sources[0]->rows);
+        static::assertNull($sources[0]->rowsError());
+    }
+
     public function test_run_explicit_analyze_overrides_config(): void
     {
         $config = config_builder()->analyze(analyze())->build();
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/FilterTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/FilterTest.php
index 48082a3f72..4006314426 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/FilterTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/FilterTest.php
@@ -6,8 +6,11 @@
 
 use Flow\ETL\Tests\FlowIntegrationTestCase;
 
+use function Flow\ETL\Adapter\CSV\from_csv;
+use function Flow\ETL\Adapter\CSV\to_csv;
 use function Flow\ETL\DSL\df;
 use function Flow\ETL\DSL\from_array;
+use function Flow\ETL\DSL\lit;
 use function Flow\ETL\DSL\ref;
 
 final class FilterTest extends FlowIntegrationTestCase
@@ -58,4 +61,22 @@ public function test_single_filter(): void
             $rows->toArray(),
         );
     }
+
+    public function test_a_filter_over_a_file_source_guards_the_filter_above_it(): void
+    {
+        $file = $this->cacheDir->path() . '/guarded-filters.csv';
+
+        df()
+            ->read(from_array([['a' => 1, 'b' => 0], ['a' => 2, 'b' => 2]]))
+            ->write(to_csv($file))
+            ->run();
+
+        $rows = df()
+            ->read(from_csv($file))
+            ->filter(ref('b')->notEquals(lit(0)))
+            ->filter(ref('a')->divide(ref('b'))->greaterThan(lit(0)))
+            ->fetch();
+
+        static::assertSame([['a' => 2, 'b' => 2]], $rows->toArray());
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/LimitTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/LimitTest.php
index 9e9e1003c1..96f93dc591 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/LimitTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/LimitTest.php
@@ -448,6 +448,7 @@ public function test_a_limit_over_a_read_frame_reaches_that_frames_source(bool $
         $rows = df()->read($nested)->offset(1)->limit(2)->fetch();
 
         static::assertSame([['id' => 2], ['id' => 3]], $rows->toArray());
-        static::assertSame([3], $source->limits);
+        static::assertCount(1, $source->scans);
+        static::assertSame(3, $source->scans[0]->limit);
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinglePlanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinglePlanTest.php
index e2f12340e5..794800a9eb 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinglePlanTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinglePlanTest.php
@@ -5,6 +5,7 @@
 namespace Flow\ETL\Tests\Integration\DataFrame;
 
 use Flow\ETL\ErrorHandler\IgnoreError;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Memory\ArrayMemory;
 use Flow\ETL\Optimizer;
 use Flow\ETL\Tests\Double\RecordingFileExtractor;
@@ -13,7 +14,6 @@
 use Flow\ETL\Tests\Mother\PartitionedSourceMother;
 use Flow\ETL\Transformation\AddRowIndex\StartFrom;
 use Flow\ETL\Transformer\AddRowIndexTransformer;
-use Flow\Filesystem\Path\Filter;
 use RuntimeException;
 
 use function array_filter;
@@ -97,7 +97,8 @@ public function test_a_joined_frame_is_optimized_with_the_outer_frames_optimizer
             ->join($right, join_on(['id' => 'id'], 'r_'))
             ->fetch();
 
-        static::assertSame([1], $source->limits);
+        static::assertCount(1, $source->scans);
+        static::assertSame(1, $source->scans[0]->limit);
     }
 
     public function test_a_joined_frames_own_error_handler_is_ignored(): void
@@ -145,11 +146,11 @@ public function test_a_filter_pushed_into_a_source_both_sides_share_leaves_the_j
             ->crossJoin($joined, 'j_')
             ->fetch();
 
-        $accepts2024 = static fn(Filter $filter): bool => $filter->accept(PartitionedSourceMother::file(
+        $accepts2024 = static fn(FileScan $scan): bool => $scan->pathFilter->accept(PartitionedSourceMother::file(
             'year=2024/month=08',
         ));
 
-        static::assertCount(2, $source->pathFilters);
-        static::assertCount(1, array_filter($source->pathFilters, $accepts2024));
+        static::assertCount(2, $source->scans);
+        static::assertCount(1, array_filter($source->scans, $accepts2024));
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinkRootTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinkRootTest.php
index 6c3b61c2a4..726a8895fd 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinkRootTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/DataFrame/SinkRootTest.php
@@ -414,7 +414,7 @@ public function test_a_later_limit_does_not_narrow_an_earlier_sink(): void
         $rows = df()->read($extractor)->write($spy)->limit(2)->fetch();
 
         static::assertCount(2, $rows);
-        static::assertNull($extractor->limits[0]);
+        static::assertNull($extractor->scans[0]->limit);
         static::assertSame([3], $spy->loadedRowCounts());
     }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/FileExtractorScanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/FileExtractorScanTest.php
new file mode 100644
index 0000000000..2e664ad1ab
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/FileExtractorScanTest.php
@@ -0,0 +1,155 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Integration\Extractor;
+
+use Flow\ETL\Extractor\File\FileExtractor;
+use Flow\ETL\Extractor\File\FileScan;
+use Flow\ETL\Optimizer;
+use Flow\ETL\Optimizer\Rule\PushFilterIntoSource;
+use Flow\ETL\Tests\Context\ExtractedRows;
+use Flow\ETL\Tests\FlowIntegrationTestCase;
+use PHPUnit\Framework\Attributes\TestWith;
+
+use function Flow\ETL\Adapter\CSV\from_csv;
+use function Flow\ETL\Adapter\CSV\to_csv;
+use function Flow\ETL\Adapter\Excel\DSL\from_excel;
+use function Flow\ETL\Adapter\Excel\DSL\to_excel;
+use function Flow\ETL\Adapter\JSON\from_json;
+use function Flow\ETL\Adapter\JSON\to_json;
+use function Flow\ETL\Adapter\Parquet\from_parquet;
+use function Flow\ETL\Adapter\Parquet\to_parquet;
+use function Flow\ETL\Adapter\Text\from_text;
+use function Flow\ETL\Adapter\Text\to_text;
+use function Flow\ETL\Adapter\XML\from_xml;
+use function Flow\ETL\Adapter\XML\to_xml;
+use function Flow\ETL\DSL\config_builder;
+use function Flow\ETL\DSL\df;
+use function Flow\ETL\DSL\files;
+use function Flow\ETL\DSL\flow_context;
+use function Flow\ETL\DSL\from_array;
+use function Flow\ETL\DSL\from_path_partitions;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
+use function Flow\ETL\DSL\rows;
+use function Flow\ETL\DSL\schema;
+use function Flow\Filesystem\DSL\path;
+use function Flow\Floe\DSL\from_floe;
+use function Flow\Floe\DSL\to_floe;
+
+/**
+ * Avro is left out: its extractor's constructor throws unconditionally.
+ */
+final class FileExtractorScanTest extends FlowIntegrationTestCase
+{
+    #[TestWith(['csv'])]
+    #[TestWith(['json'])]
+    #[TestWith(['text'])]
+    #[TestWith(['xml'])]
+    #[TestWith(['excel'])]
+    #[TestWith(['parquet'])]
+    #[TestWith(['floe'])]
+    #[TestWith(['files'])]
+    #[TestWith(['path_partitions'])]
+    public function test_extract_with_a_limit_reads_what_scan_with_that_limit_reads(string $family): void
+    {
+        $directory = $this->cacheDir->path() . '/scan-' . $family;
+        $uri = path($directory . '/rows.' . $family);
+        $xlsx = path($directory . '/rows.xlsx');
+
+        [$sink, $extractor] = match ($family) {
+            'csv' => [to_csv($uri), from_csv($uri)],
+            'json' => [to_json($uri), from_json($uri)],
+            'text' => [to_text($uri), from_text($uri)],
+            'xml' => [to_xml($uri), from_xml($uri)],
+            'excel' => [to_excel($xlsx), from_excel($xlsx)],
+            'parquet' => [to_parquet($uri), from_parquet($uri)],
+            'floe' => [to_floe($uri), from_floe($uri)],
+            'files' => [to_csv($uri), files($directory . '/*')],
+            default => [to_csv(path($directory . '/id=a/rows.csv')), from_path_partitions($directory . '/*/*.csv')],
+        };
+
+        df()
+            ->read(from_array([['id' => 'a'], ['id' => 'b'], ['id' => 'c']]))
+            ->write($sink)
+            ->run();
+
+        $context = flow_context();
+        $scanned = rows(schema());
+
+        foreach ($extractor->scan($context, new FileScan(limit: 2)) as $batch) {
+            $scanned = $scanned->isEmpty() ? $batch : $scanned->concat($context->backend(), $batch);
+        }
+
+        static::assertNotSame([], $scanned->toArray());
+        static::assertEquals(ExtractedRows::of($extractor, $context, new FileScan(2))->toArray(), $scanned->toArray());
+    }
+
+    #[TestWith(['csv'])]
+    #[TestWith(['json'])]
+    #[TestWith(['text'])]
+    #[TestWith(['xml'])]
+    #[TestWith(['excel'])]
+    #[TestWith(['parquet'])]
+    #[TestWith(['floe'])]
+    #[TestWith(['files'])]
+    #[TestWith(['path_partitions'])]
+    public function test_a_pushed_filter_returns_what_the_filter_node_returns(string $family): void
+    {
+        $directory = $this->cacheDir->path() . '/pushed-' . $family;
+        $uri = path($directory . '/rows.' . $family);
+        $xlsx = path($directory . '/rows.xlsx');
+
+        [$sink, $extractor, $predicate] = match ($family) {
+            'csv' => [to_csv($uri), static fn(): FileExtractor => from_csv($uri), ref('id')->notEquals(lit('b'))],
+            'json' => [to_json($uri), static fn(): FileExtractor => from_json($uri), ref('id')->notEquals(lit('b'))],
+            'text' => [to_text($uri), static fn(): FileExtractor => from_text($uri), ref('text')->notEquals(lit('b'))],
+            'xml' => [
+                to_xml($uri),
+                static fn(): FileExtractor => from_xml($uri, 'rows/row'),
+                ref('node')->xpath('id')->domElementValue()->notEquals(lit('b')),
+            ],
+            'excel' => [
+                to_excel($xlsx),
+                static fn(): FileExtractor => from_excel($xlsx),
+                ref('id')->notEquals(lit('b')),
+            ],
+            'parquet' => [
+                to_parquet($uri),
+                static fn(): FileExtractor => from_parquet($uri),
+                ref('id')->notEquals(lit('b')),
+            ],
+            'floe' => [to_floe($uri), static fn(): FileExtractor => from_floe($uri), ref('id')->notEquals(lit('b'))],
+            'files' => [null, static fn(): FileExtractor => files($directory . '/*/*'), ref('id')->notEquals(lit('b'))],
+            default => [
+                null,
+                static fn(): FileExtractor => from_path_partitions($directory . '/*/*'),
+                ref('id')->notEquals(lit('b')),
+            ],
+        };
+
+        if ($sink === null) {
+            foreach (['a', 'b', 'c'] as $id) {
+                df()
+                    ->read(from_array([['id' => $id]]))
+                    ->write(to_csv(path($directory . '/id=' . $id . '/rows.csv')))
+                    ->run();
+            }
+        } else {
+            df()
+                ->read(from_array([['id' => 'a'], ['id' => 'b'], ['id' => 'c']]))
+                ->write($sink)
+                ->run();
+        }
+
+        $pushed = df()->read($extractor())->filter($predicate)->fetch();
+        $plain = df(config_builder()->optimizer(Optimizer::default()->without(PushFilterIntoSource::class)))
+            ->read($extractor())
+            ->filter($predicate)
+            ->fetch();
+
+        static::assertCount(2, $plain);
+        static::assertEquals($plain->toArray(), $pushed->toArray());
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/PathPartitionsExtractorTest.php b/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/PathPartitionsExtractorTest.php
index f048299c3a..4a3aefbd36 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/PathPartitionsExtractorTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Integration/Extractor/PathPartitionsExtractorTest.php
@@ -6,6 +6,7 @@
 
 use Flow\ETL\Cardinality;
 use Flow\ETL\Column\PhpBackend;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\PathPartitionsExtractor;
 use Flow\ETL\Rows;
 use Flow\ETL\Tests\Context\ExtractedRows;
@@ -16,7 +17,9 @@
 
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\from_path_partitions;
+use function Flow\ETL\DSL\lit;
 use function Flow\ETL\DSL\map_schema;
+use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\rows;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
@@ -243,4 +246,20 @@ public function test_path_partitions_extractor_honours_the_batch_contract(): voi
             ),
         );
     }
+
+    public function test_a_scan_returns_only_the_files_matching_its_filter(): void
+    {
+        $batches = iterator_to_array(from_path_partitions('memory://dir/**/*.txt', MemoryFiles::with([
+            'memory://dir/year=2021/a.txt' => 'a',
+            'memory://dir/year=2022/b.txt' => 'b',
+            'memory://dir/year=2023/c.txt' => 'c',
+            'memory://dir/year=2024/d.txt' => 'd',
+            'memory://dir/year=2025/e.txt' => 'e',
+        ]))
+            ->withBatchSize(2)
+            ->scan(flow_context(), new FileScan(conjuncts: [ref('year')->isIn(lit(['2023', '2024']))])), false);
+
+        static::assertCount(1, $batches);
+        static::assertSame(['2023', '2024'], $batches[0]->column('year')->values());
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Mother/PartitionedSourceMother.php b/src/core/etl/tests/Flow/ETL/Tests/Mother/PartitionedSourceMother.php
index a6d27a9281..bbdbb81314 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Mother/PartitionedSourceMother.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Mother/PartitionedSourceMother.php
@@ -22,8 +22,8 @@ public static function partitions(): Schema
     }
 
     /**
-     * One row per partition. The double ignores the pushed path filter, so only a Filter node the planner kept can
-     * drop the other partition's row.
+     * One row per partition. The double ignores the pushed path filter, so only the scan's filter or a Filter node
+     * the planner kept can drop the other partition's row.
      */
     public static function yearMonth(): RecordingFileExtractor
     {
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Column/Physical/PhysicalForTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Column/Physical/PhysicalForTest.php
index 42ee0b927d..77dcd65dd9 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Column/Physical/PhysicalForTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Column/Physical/PhysicalForTest.php
@@ -130,7 +130,7 @@ public static function supported(): Generator
         foreach (self::types() as $name => [$type]) {
             yield $name => [
                 $type,
-                !in_array($name, ['positive integer', 'non-empty string', 'numeric string', 'class string'], true),
+                !in_array($name, ['positive integer', 'non-empty string', 'class string'], true),
             ];
         }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Config/Telemetry/TelemetryContextTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Config/Telemetry/TelemetryContextTest.php
index 83d3cdcb0c..06d2628298 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Config/Telemetry/TelemetryContextTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Config/Telemetry/TelemetryContextTest.php
@@ -990,8 +990,8 @@ public function test_optimizer_rules_are_logged(): void
             [
                 CombineLimits::class,
                 CombineSortAndLimit::class,
-                PushLimitIntoSource::class,
                 PushFilterIntoSource::class,
+                PushLimitIntoSource::class,
                 CountFromStatistics::class,
                 PushProjectionIntoExpand::class,
             ],
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/DataFrameTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/DataFrameTest.php
index e9e50824f2..9a7205e89f 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/DataFrameTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/DataFrameTest.php
@@ -958,9 +958,9 @@ public function test_a_pushed_limit_reaches_extract_and_leaves_the_users_extract
 
         static::assertSame([['id' => 1, 'doubled' => 2]], $frame->fetch()->toArray());
         static::assertSame([['id' => 1, 'doubled' => 2]], $frame->fetch()->toArray());
-        static::assertCount(2, $extractor->limits);
-        static::assertSame(1, $extractor->limits[0]);
-        static::assertSame(1, $extractor->limits[1]);
+        static::assertCount(2, $extractor->scans);
+        static::assertSame(1, $extractor->scans[0]->limit);
+        static::assertSame(1, $extractor->scans[1]->limit);
         static::assertStringEndsWith(
             "#1 Read\n            Extractor: RecordingFileExtractor\n            Source: file:///dev/null",
             $frame->explain()->toString(Stage::unoptimized),
@@ -985,7 +985,7 @@ public function test_a_limit_inside_a_joins_right_side_is_pushed_into_that_sourc
             ->join($right, join_on(['id' => 'id'], 'r_'))
             ->fetch();
 
-        static::assertSame(1, $extractor->limits[0]);
+        static::assertSame(1, $extractor->scans[0]->limit);
     }
 
     public function test_an_empty_fetch_plans_once(): void
@@ -1112,7 +1112,7 @@ public function test_a_limit_inside_a_read_frame_is_pushed_into_its_source(): vo
         $inner = df()->read($extractor)->limit(1);
 
         static::assertSame([['id' => 1]], df()->read(from_data_frame($inner))->fetch()->toArray());
-        static::assertSame(1, $extractor->limits[0]);
+        static::assertSame(1, $extractor->scans[0]->limit);
     }
 
     public function test_explain_without_sinks_prints_one_result_over_the_chain(): void
@@ -1122,8 +1122,8 @@ public function test_explain_without_sinks_prints_one_result_over_the_chain(): v
         static::assertSame(<<<'PLAN'
             #3 Result  preserving · transparent · streaming
             │  Rows this plan hands out: to the trigger, or to the node reading it
-            └─ #2 Select  preserving · transparent · streaming
-               │  Columns: id
+            └─ #2 Select  preserving · transparent · streaming · redefines all but id
+               │  Keeps only: id
                └─ #1 Read  source · transparent · streaming
                      Extractor: ArrayExtractor
             PLAN, $dataFrame->explain()->toString(format: Format::declarations));
@@ -1140,8 +1140,8 @@ public function test_explain_with_a_sink_prints_the_outputs_sharing_the_chain():
             Outputs  preserving · opaque · streaming
             ├─ #3 Result  preserving · transparent · streaming
             │  │  Rows this plan hands out: to the trigger, or to the node reading it
-            │  └─ #2 Select  preserving · transparent · streaming
-            │     │  Columns: id
+            │  └─ #2 Select  preserving · transparent · streaming · redefines all but id
+            │     │  Keeps only: id
             │     └─ #1 Read  source · transparent · streaming
             │           Extractor: ArrayExtractor
             └─ #4 Write  preserving · opaque · streaming
@@ -1173,8 +1173,8 @@ public function test_explain_of_the_run_trigger_keeps_a_result_over_a_chain_end_
             Outputs  preserving · opaque · streaming
             ├─ #3 Result  preserving · transparent · streaming
             │  │  Rows this plan hands out: to the trigger, or to the node reading it
-            │  └─ #2 Select  preserving · transparent · streaming
-            │     │  Columns: id
+            │  └─ #2 Select  preserving · transparent · streaming · redefines all but id
+            │     │  Keeps only: id
             │     └─ #1 Read  source · transparent · streaming
             │           Extractor: ArrayExtractor
             └─ #4 Write  preserving · opaque · streaming
@@ -1203,15 +1203,14 @@ public function test_explain_prints_the_logical_plan_without_reading_a_row(): vo
         $dataFrame = df()->read($extractor)->filter(ref('id')->isNotNull())->write(to_memory(new ArrayMemory()));
 
         static::assertSame(<<<'PLAN'
-            #3 Write  preserving · opaque · streaming
+            #2 Write  preserving · opaque · streaming
             │  Loader: MemoryLoader
-            └─ #2 Filter  reducing · transparent · streaming
-               │  Condition: IsNotNull
-               └─ #1 Read  source · transparent · streaming
-                     Extractor: RecordingFileExtractor
-                     Source: file:///dev/null
+            └─ #1 Read  source · transparent · streaming
+                  Extractor: RecordingFileExtractor
+                  Source: file:///dev/null
+                  Filter: IsNotNull
             PLAN, $dataFrame->explain()->toString(format: Format::declarations));
-        static::assertSame([], $extractor->limits);
+        static::assertSame([], $extractor->scans);
     }
 
     public function test_from_data_frame_reads_the_frame_as_a_source(): void
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Executor/PipelineTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Executor/PipelineTest.php
index c7da1b6421..21a448113d 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Executor/PipelineTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Executor/PipelineTest.php
@@ -7,9 +7,9 @@
 use Flow\ETL\Executor\Pipeline;
 use Flow\ETL\Executor\Segments;
 use Flow\ETL\Executor\SourceRows;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\ETL\Tests\Mother\NodeMother;
-use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Flow\Filesystem\Tests\Double\RejectingFilter;
 
 use function Flow\ETL\DSL\from_array;
@@ -21,18 +21,16 @@ public function test_accessors_return_the_values_it_was_built_with(): void
         $segments = new Segments();
         $context = NodeMother::context();
         $input = new Pipeline(0, new Segments(from_array([['id' => 1]])), $context);
-        $filter = new RejectingFilter();
-
+        $scan = new FileScan(3, new RejectingFilter());
         $sources = new SourceRows();
 
-        $pipeline = new Pipeline(1, $segments, $context, $input, 3, $filter, $sources);
+        $pipeline = new Pipeline(1, $segments, $context, $input, $scan, $sources);
 
         static::assertSame(1, $pipeline->id);
         static::assertSame($segments, $pipeline->segments());
         static::assertSame($context, $pipeline->context());
         static::assertSame($input, $pipeline->input());
-        static::assertSame(3, $pipeline->limit());
-        static::assertSame($filter, $pipeline->pathFilter());
+        static::assertSame($scan, $pipeline->scan());
         static::assertSame($sources, $pipeline->sources());
     }
 
@@ -41,8 +39,7 @@ public function test_a_leaf_pipeline_defaults_to_no_input_no_limit_and_only_file
         $pipeline = new Pipeline(0, new Segments(from_array([['id' => 1]])), NodeMother::context());
 
         static::assertNull($pipeline->input());
-        static::assertNull($pipeline->limit());
-        static::assertInstanceOf(OnlyFiles::class, $pipeline->pathFilter());
+        static::assertEquals(new FileScan(), $pipeline->scan());
         static::assertNull($pipeline->sources());
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/ExecutorTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/ExecutorTest.php
index efeb84abb4..2b4f76aa06 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/ExecutorTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/ExecutorTest.php
@@ -12,6 +12,7 @@
 use Flow\ETL\Executor\Pipeline;
 use Flow\ETL\Executor\Raw;
 use Flow\ETL\Executor\Segments;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Optimizer;
 use Flow\ETL\Plan\Node\Transform;
 use Flow\ETL\Processor\BatchingProcessor;
@@ -186,17 +187,16 @@ public function test_a_pipeline_without_a_source_throws(): void
         iterator_to_array((new Executor())->executePipeline(new Pipeline(7, new Segments(), NodeMother::context())));
     }
 
-    public function test_a_file_source_receives_the_pipelines_limit_and_path_filter(): void
+    public function test_a_file_source_receives_the_pipelines_scan(): void
     {
         $extractor = new RecordingFileExtractor(schema(int_schema('id')), RowsMother::sequentialIds(1));
-        $filter = new RejectingFilter();
+        $scan = new FileScan(7, new RejectingFilter());
 
         iterator_to_array((new Executor())->executePipeline(
-            new Pipeline(0, new Segments($extractor), NodeMother::context(), limit: 7, pathFilter: $filter),
+            new Pipeline(0, new Segments($extractor), NodeMother::context(), scan: $scan),
         ));
 
-        static::assertSame([7], $extractor->limits);
-        static::assertSame([$filter], $extractor->pathFilters);
+        static::assertSame([$scan], $extractor->scans);
     }
 
     public function test_a_source_that_lists_no_files_receives_the_pipelines_limit(): void
@@ -204,7 +204,7 @@ public function test_a_source_that_lists_no_files_receives_the_pipelines_limit()
         $extractor = new RecordingExtractor(schema(int_schema('id')), RowsMother::sequentialIds(1));
 
         iterator_to_array((new Executor())->executePipeline(
-            new Pipeline(0, new Segments($extractor), NodeMother::context(), limit: 7),
+            new Pipeline(0, new Segments($extractor), NodeMother::context(), scan: new FileScan(7)),
         ));
 
         static::assertSame([7], $extractor->limits);
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/DataFrameExtractorTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/DataFrameExtractorTest.php
index dc607111f5..4bc0922602 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/DataFrameExtractorTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/DataFrameExtractorTest.php
@@ -162,7 +162,8 @@ public function test_a_limit_given_to_extract_reaches_the_frames_source(): void
 
         $batches = iterator_to_array(from_data_frame(df()->read($source))->extract(flow_context(config()), 2), false);
 
-        static::assertSame([2], $source->limits);
+        static::assertCount(1, $source->scans);
+        static::assertSame(2, $source->scans[0]->limit);
         static::assertSame(
             [['id' => 1], ['id' => 2]],
             array_merge(...array_map(static fn($rows) => $rows->toArray(), $batches)),
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileMetadataRowTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileMetadataRowTest.php
new file mode 100644
index 0000000000..a29fd6bfd2
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileMetadataRowTest.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Extractor\File;
+
+use Flow\ETL\Extractor\File\FileMetadataRow;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\Filesystem\FileStatus;
+
+use function Flow\Filesystem\DSL\path;
+
+final class FileMetadataRowTest extends FlowTestCase
+{
+    public function test_a_file_is_described_by_its_path_names_kind_and_extension(): void
+    {
+        static::assertSame(
+            [
+                'path' => '/dir/a.csv',
+                'protocol' => 'memory',
+                'file_name' => 'a',
+                'base_name' => 'a.csv',
+                'is_file' => true,
+                'is_dir' => false,
+                'extension' => 'csv',
+            ],
+            (new FileMetadataRow())->row(new FileStatus(path('memory://dir/a.csv'), true)),
+        );
+    }
+
+    public function test_a_file_without_an_extension_has_a_null_extension(): void
+    {
+        static::assertNull((new FileMetadataRow())->row(new FileStatus(path('memory://dir/a'), true))['extension']);
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileReadLoopTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileReadLoopTest.php
index 7357642e5f..5a22c67cd2 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileReadLoopTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileReadLoopTest.php
@@ -4,7 +4,6 @@
 
 namespace Flow\ETL\Tests\Unit\Extractor\File;
 
-use Flow\ETL\Column\PhpBackend;
 use Flow\ETL\Extractor\File\FileReadLoop;
 use Flow\ETL\Extractor\File\ReadWindow;
 use Flow\ETL\Extractor\File\SourceFile;
@@ -17,7 +16,10 @@
 
 use function array_keys;
 use function array_map;
+use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
 use function Flow\Filesystem\DSL\path;
@@ -40,7 +42,7 @@ public function test_every_batch_carries_its_files_constants(): void
             ],
             $batches,
             10,
-            new PhpBackend(),
+            flow_context(),
             new ReadWindow(),
         ));
 
@@ -56,7 +58,7 @@ public function test_stop_after_the_first_batch_ends_the_read(): void
             [new SourceFile(path('memory://a.csv')), new SourceFile(path('memory://b.csv'))],
             new InMemoryFileBatches(['memory://a.csv' => [1, 2, 3], 'memory://b.csv' => [4]]),
             1,
-            new PhpBackend(),
+            flow_context(),
             new ReadWindow(),
         );
 
@@ -78,7 +80,7 @@ public function test_a_limit_inside_a_file_ends_the_read_and_is_pushed_down(): v
             [new SourceFile(path('memory://a.csv')), new SourceFile(path('memory://b.csv'))],
             $batches,
             10,
-            new PhpBackend(),
+            flow_context(),
             new ReadWindow(limit: 2),
         ));
 
@@ -100,7 +102,7 @@ public function test_a_limit_at_a_file_boundary_opens_no_further_file(): void
             [new SourceFile(path('memory://a.csv')), new SourceFile(path('memory://b.csv'))],
             $batches,
             1,
-            new PhpBackend(),
+            flow_context(),
             new ReadWindow(limit: 2),
         ));
 
@@ -127,7 +129,7 @@ public function test_the_offset_a_file_leaves_and_the_rows_still_wanted_reach_th
             ],
             $batches,
             10,
-            new PhpBackend(),
+            flow_context(),
             new ReadWindow(offset: 3, limit: 2),
         ));
 
@@ -152,7 +154,7 @@ public function test_no_sources_read_nothing(): void
             iterator_to_array((new FileReadLoop(
                 FileColumnsContext::discovering(names: []),
                 schema(int_schema('id')),
-            ))->read([], new InMemoryFileBatches([]), 10, new PhpBackend(), new ReadWindow())),
+            ))->read([], new InMemoryFileBatches([]), 10, flow_context(), new ReadWindow())),
         );
     }
 
@@ -173,7 +175,7 @@ public function test_the_loop_slices_the_offset_a_format_cannot_skip_across_file
                 ],
                 $batches,
                 10,
-                new PhpBackend(),
+                flow_context(),
                 new ReadWindow(offset: 3, limit: 2),
             ),
             false,
@@ -202,7 +204,7 @@ public function test_the_loop_skips_the_offset_and_trims_to_the_limit_for_a_form
                 [new SourceFile(path('memory://a.csv'))],
                 $batches,
                 10,
-                new PhpBackend(),
+                flow_context(),
                 new ReadWindow(offset: 3, limit: 2),
             ),
             false,
@@ -214,4 +216,127 @@ public function test_the_loop_skips_the_offset_and_trims_to_the_limit_for_a_form
         );
         static::assertEquals(['memory://a.csv' => [new ReadWindow(0, 5)]], $batches->windows);
     }
+
+    public function test_a_filter_drops_the_rows_it_does_not_match_and_skips_a_batch_it_empties(): void
+    {
+        $rows = iterator_to_array(
+            (new FileReadLoop(FileColumnsContext::discovering(names: []), schema(int_schema('id')), [ref(
+                'id',
+            )->greaterThan(lit(
+                2,
+            ))]))->read([new SourceFile(path('memory://a.csv'))], new InMemoryFileBatches(['memory://a.csv' => [1, 2, 3, 4, 5]]), 2, flow_context(), new ReadWindow()),
+            false,
+        );
+
+        static::assertSame(
+            [[['id' => 3], ['id' => 4]], [['id' => 5]]],
+            array_map(static fn(Rows $batch): array => $batch->toArray(), $rows),
+        );
+    }
+
+    public function test_a_filter_mixing_a_body_and_a_partition_column_sees_the_partition_values(): void
+    {
+        $rows = iterator_to_array(
+            (new FileReadLoop(FileColumnsContext::discovering(), schema(int_schema('id'), str_schema('year')), [
+                ref('year')->equals(lit('2024')),
+                ref('id')->greaterThan(lit(3)),
+            ]))->read([
+                new SourceFile(path('memory://orders/year=2023/a.csv')),
+                new SourceFile(path('memory://orders/year=2024/b.csv')),
+            ], new InMemoryFileBatches([
+                'memory://orders/year=2023/a.csv' => [4, 5],
+                'memory://orders/year=2024/b.csv' => [3, 4],
+            ]), 10, flow_context(), new ReadWindow()),
+            false,
+        );
+
+        static::assertSame(
+            [[['id' => 4, 'year' => '2024']]],
+            array_map(static fn(Rows $batch): array => $batch->toArray(), $rows),
+        );
+    }
+
+    public function test_the_offset_counts_raw_rows_and_the_limit_counts_filtered_ones(): void
+    {
+        $batches = new InMemoryFileBatches(['memory://a.csv' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]);
+
+        $rows = iterator_to_array(
+            (new FileReadLoop(FileColumnsContext::discovering(names: []), schema(int_schema('id')), [ref(
+                'id',
+            )->greaterThan(lit(
+                5,
+            ))]))->read([new SourceFile(path('memory://a.csv'))], $batches, 10, flow_context(), new ReadWindow(offset: 6, limit: 2)),
+            false,
+        );
+
+        static::assertSame(
+            [[['id' => 7], ['id' => 8]]],
+            array_map(static fn(Rows $batch): array => $batch->toArray(), $rows),
+        );
+        static::assertEquals(['memory://a.csv' => [new ReadWindow(6)]], $batches->windows);
+    }
+
+    public function test_the_loop_drops_the_raw_offset_before_the_filter_for_a_format_that_cannot_skip(): void
+    {
+        $batches = new InMemoryUnskippableFileBatches(['memory://a.csv' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]);
+
+        $rows = iterator_to_array(
+            (new FileReadLoop(FileColumnsContext::discovering(names: []), schema(int_schema('id')), [ref(
+                'id',
+            )->greaterThan(lit(
+                5,
+            ))]))->read([new SourceFile(path('memory://a.csv'))], $batches, 10, flow_context(), new ReadWindow(offset: 6, limit: 2)),
+            false,
+        );
+
+        static::assertSame(
+            [[['id' => 7], ['id' => 8]]],
+            array_map(static fn(Rows $batch): array => $batch->toArray(), $rows),
+        );
+        static::assertEquals(['memory://a.csv' => [new ReadWindow()]], $batches->windows);
+    }
+
+    public function test_a_limit_beside_a_filter_counts_matching_rows_across_files_and_opens_no_further_file(): void
+    {
+        $batches = new InMemoryFileBatches([
+            'memory://a.csv' => [1, 2],
+            'memory://b.csv' => [3, 4],
+            'memory://c.csv' => [5],
+        ]);
+
+        $rows = iterator_to_array(
+            (new FileReadLoop(FileColumnsContext::discovering(names: []), schema(int_schema('id')), [ref(
+                'id',
+            )->greaterThan(lit(
+                1,
+            ))]))->read([
+                new SourceFile(path('memory://a.csv')),
+                new SourceFile(path('memory://b.csv')),
+                new SourceFile(path('memory://c.csv')),
+            ], $batches, 10, flow_context(), new ReadWindow(limit: 2)),
+            false,
+        );
+
+        static::assertSame(
+            [[['id' => 2]], [['id' => 3]]],
+            array_map(static fn(Rows $batch): array => $batch->toArray(), $rows),
+        );
+        static::assertEquals(
+            ['memory://a.csv' => [new ReadWindow()], 'memory://b.csv' => [new ReadWindow()]],
+            $batches->windows,
+        );
+    }
+
+    public function test_each_conjunct_of_the_filter_sees_only_the_rows_the_ones_before_it_kept(): void
+    {
+        $rows = iterator_to_array(
+            (new FileReadLoop(FileColumnsContext::discovering(names: []), schema(int_schema('id')), [
+                ref('id')->notEquals(lit(0)),
+                lit(10)->divide(ref('id'))->greaterThan(lit(1)),
+            ]))->read([new SourceFile(path('memory://a.csv'))], new InMemoryFileBatches(['memory://a.csv' => [0, 2, 10]]), 10, flow_context(), new ReadWindow()),
+            false,
+        );
+
+        static::assertSame([[['id' => 2]]], array_map(static fn(Rows $batch): array => $batch->toArray(), $rows));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileScanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileScanTest.php
new file mode 100644
index 0000000000..8a6a115393
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/FileScanTest.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Extractor\File;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Extractor\File\FileScan;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\Filesystem\Path\Filter\Filters;
+use Flow\Filesystem\Path\Filter\OnlyFiles;
+use Flow\Filesystem\Tests\Double\RejectingFilter;
+use PHPUnit\Framework\Attributes\TestWith;
+
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
+
+final class FileScanTest extends FlowTestCase
+{
+    public function test_a_default_scan_pushes_nothing_and_narrows_nothing(): void
+    {
+        $scan = new FileScan();
+
+        static::assertNull($scan->limit);
+        static::assertInstanceOf(OnlyFiles::class, $scan->pathFilter);
+        static::assertSame([], $scan->conjuncts);
+        static::assertFalse($scan->narrows());
+    }
+
+    #[TestWith([0])]
+    #[TestWith([-1])]
+    public function test_a_limit_below_one_is_refused(int $limit): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Limit must be greater than 0');
+
+        new FileScan($limit);
+    }
+
+    public function test_a_filter_appends_its_conjuncts_in_push_order(): void
+    {
+        $first = ref('id')->greaterThan(lit(1));
+        $second = ref('id')->lessThan(lit(10));
+        $third = ref('id')->notEquals(lit(5));
+
+        $scan = (new FileScan(5))
+            ->withFilter($first)
+            ->withFilter($second->and($third));
+
+        static::assertSame([$first, $second, $third], $scan->conjuncts);
+        static::assertSame(5, $scan->limit);
+        static::assertTrue($scan->narrows());
+    }
+
+    public function test_a_second_limit_only_lowers_the_first_and_keeps_the_conjuncts(): void
+    {
+        $filter = ref('id')->greaterThan(lit(1));
+        $scan = (new FileScan())
+            ->withFilter($filter)
+            ->withLimit(5);
+
+        static::assertSame(3, $scan->withLimit(3)->limit);
+        static::assertSame(5, $scan->withLimit(8)->limit);
+        static::assertSame([$filter], $scan->withLimit(8)->conjuncts);
+        static::assertTrue(
+            (new FileScan())
+                ->withLimit(1)
+                ->narrows(),
+        );
+    }
+
+    public function test_path_filters_compose_and_keep_the_conjuncts(): void
+    {
+        $filter = ref('id')->greaterThan(lit(1));
+        $first = new RejectingFilter();
+        $second = new RejectingFilter();
+
+        $scan = (new FileScan())
+            ->withFilter($filter)
+            ->withPathFilter($first)
+            ->withPathFilter($second);
+
+        static::assertEquals(new Filters(new OnlyFiles(), $first, $second), $scan->pathFilter);
+        static::assertSame([$filter], $scan->conjuncts);
+        static::assertTrue(
+            (new FileScan())
+                ->withPathFilter($first)
+                ->narrows(),
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/ListingScanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/ListingScanTest.php
new file mode 100644
index 0000000000..fa5ffc405f
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/ListingScanTest.php
@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Extractor\File;
+
+use Flow\ETL\Extractor\File\FileColumns;
+use Flow\ETL\Extractor\File\FileScan;
+use Flow\ETL\Extractor\File\ListingScan;
+use Flow\ETL\Extractor\File\PartitionColumns;
+use Flow\ETL\Extractor\File\PartitionTypes;
+use Flow\ETL\Extractor\File\PathPartitionsRow;
+use Flow\ETL\Extractor\Signal;
+use Flow\ETL\Rows;
+use Flow\ETL\Tests\Context\MemoryFiles;
+use Flow\ETL\Tests\FlowTestCase;
+
+use function array_map;
+use function Flow\ETL\DSL\flow_context;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\map_schema;
+use function Flow\ETL\DSL\ref;
+use function Flow\ETL\DSL\schema;
+use function Flow\ETL\DSL\str_schema;
+use function Flow\Filesystem\DSL\path;
+use function Flow\Types\DSL\type_map;
+use function Flow\Types\DSL\type_string;
+use function iterator_to_array;
+
+final class ListingScanTest extends FlowTestCase
+{
+    public function test_each_listed_file_is_one_row_in_batches_of_the_batch_size(): void
+    {
+        $filesystem = MemoryFiles::with(['memory://dir/a' => 'a', 'memory://dir/b' => 'b', 'memory://dir/c' => 'c']);
+
+        static::assertSame(
+            [['memory://dir/a', 'memory://dir/b'], ['memory://dir/c']],
+            array_map(
+                static fn(Rows $rows): array => $rows->reduceToArray('path'),
+                iterator_to_array(
+                    (new ListingScan(
+                        $filesystem,
+                        path('memory://dir/*'),
+                        new FileColumns(new PartitionColumns($filesystem), [], new PartitionTypes(), false),
+                        new PathPartitionsRow(),
+                    ))->scan(
+                        flow_context(),
+                        new FileScan(),
+                        schema(str_schema('path'), map_schema('partitions', type_map(type_string(), type_string()))),
+                        2,
+                    ),
+                    false,
+                ),
+            ),
+        );
+    }
+
+    public function test_a_batch_holds_only_the_files_every_conjunct_keeps_and_an_emptied_batch_is_skipped(): void
+    {
+        $filesystem = MemoryFiles::with(['memory://dir/a' => 'a', 'memory://dir/b' => 'b', 'memory://dir/c' => 'c']);
+
+        static::assertSame(
+            [['memory://dir/c']],
+            array_map(
+                static fn(Rows $rows): array => $rows->reduceToArray('path'),
+                iterator_to_array(
+                    (new ListingScan(
+                        $filesystem,
+                        path('memory://dir/*'),
+                        new FileColumns(new PartitionColumns($filesystem), [], new PartitionTypes(), false),
+                        new PathPartitionsRow(),
+                    ))->scan(
+                        flow_context(),
+                        new FileScan(conjuncts: [
+                            ref('path')->notEquals(lit('memory://dir/a')),
+                            ref('path')->notEquals(lit('memory://dir/b')),
+                        ]),
+                        schema(str_schema('path'), map_schema('partitions', type_map(type_string(), type_string()))),
+                        2,
+                    ),
+                    false,
+                ),
+            ),
+        );
+    }
+
+    public function test_the_scan_stops_once_the_limit_of_rows_is_handed_out(): void
+    {
+        $filesystem = MemoryFiles::with(['memory://dir/a' => 'a', 'memory://dir/b' => 'b', 'memory://dir/c' => 'c']);
+
+        static::assertCount(1, iterator_to_array(
+            (new ListingScan(
+                $filesystem,
+                path('memory://dir/*'),
+                new FileColumns(new PartitionColumns($filesystem), [], new PartitionTypes(), false),
+                new PathPartitionsRow(),
+            ))->scan(
+                flow_context(),
+                new FileScan(limit: 1),
+                schema(str_schema('path'), map_schema('partitions', type_map(type_string(), type_string()))),
+                1,
+            ),
+            false,
+        ));
+    }
+
+    public function test_a_batch_past_the_limit_is_trimmed_to_it(): void
+    {
+        $filesystem = MemoryFiles::with(['memory://dir/a' => 'a', 'memory://dir/b' => 'b', 'memory://dir/c' => 'c']);
+
+        static::assertSame(
+            [['memory://dir/a', 'memory://dir/b']],
+            array_map(
+                static fn(Rows $rows): array => $rows->reduceToArray('path'),
+                iterator_to_array(
+                    (new ListingScan(
+                        $filesystem,
+                        path('memory://dir/*'),
+                        new FileColumns(new PartitionColumns($filesystem), [], new PartitionTypes(), false),
+                        new PathPartitionsRow(),
+                    ))->scan(
+                        flow_context(),
+                        new FileScan(limit: 2),
+                        schema(str_schema('path'), map_schema('partitions', type_map(type_string(), type_string()))),
+                        3,
+                    ),
+                    false,
+                ),
+            ),
+        );
+    }
+
+    public function test_a_stop_signal_ends_the_scan(): void
+    {
+        $filesystem = MemoryFiles::with(['memory://dir/a' => 'a', 'memory://dir/b' => 'b']);
+        $scan = (new ListingScan(
+            $filesystem,
+            path('memory://dir/*'),
+            new FileColumns(new PartitionColumns($filesystem), [], new PartitionTypes(), false),
+            new PathPartitionsRow(),
+        ))->scan(
+            flow_context(),
+            new FileScan(),
+            schema(str_schema('path'), map_schema('partitions', type_map(type_string(), type_string()))),
+            1,
+        );
+
+        static::assertSame(['memory://dir/a'], $scan->current()->reduceToArray('path'));
+
+        $scan->send(Signal::STOP);
+
+        static::assertFalse($scan->valid());
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/PathPartitionsRowTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/PathPartitionsRowTest.php
new file mode 100644
index 0000000000..f302978165
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/File/PathPartitionsRowTest.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Extractor\File;
+
+use Flow\ETL\Extractor\File\PathPartitionsRow;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\Filesystem\FileStatus;
+
+use function Flow\Filesystem\DSL\path;
+
+final class PathPartitionsRowTest extends FlowTestCase
+{
+    public function test_a_file_is_described_by_its_uri_and_its_partitions(): void
+    {
+        static::assertSame(
+            ['path' => 'memory://dir/year=2024/month=01/a.csv', 'partitions' => ['year' => '2024', 'month' => '01']],
+            (new PathPartitionsRow())->row(new FileStatus(path('memory://dir/year=2024/month=01/a.csv'), true)),
+        );
+    }
+
+    public function test_a_file_outside_partitions_has_none(): void
+    {
+        static::assertSame(
+            [],
+            (new PathPartitionsRow())->row(new FileStatus(path('memory://dir/a.csv'), true))['partitions'],
+        );
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/FilesExtractorTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/FilesExtractorTest.php
index 62e717d70f..b9308f80b8 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/FilesExtractorTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Extractor/FilesExtractorTest.php
@@ -5,6 +5,7 @@
 namespace Flow\ETL\Tests\Unit\Extractor;
 
 use Flow\ETL\Cardinality;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\FilesExtractor;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Schema;
@@ -16,6 +17,8 @@
 
 use function Flow\ETL\DSL\files;
 use function Flow\ETL\DSL\flow_context;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\str_schema;
 use function iterator_to_array;
@@ -139,7 +142,7 @@ public function test_extracting_files_from_directory_with_limit(): void
     {
         $extractor = files(__DIR__ . '/Fixtures/FileListExtractor/**/*')->withBatchSize(1);
 
-        self::assertExtractedRowsCount(2, $extractor, limit: 2);
+        self::assertExtractedRowsCount(2, $extractor, scan: new FileScan(2));
     }
 
     public function test_is_repeatable(): void
@@ -202,4 +205,20 @@ public function test_files_extractor_honours_the_batch_contract(): void
             ExtractedRows::of(files(__DIR__ . '/Fixtures/FileListExtractor/**/*')->withBatchSize(1)),
         );
     }
+
+    public function test_a_scan_returns_only_the_files_matching_its_filter(): void
+    {
+        $batches = iterator_to_array(files('memory://dir/*.txt', MemoryFiles::with([
+            'memory://dir/a.txt' => 'a',
+            'memory://dir/b.txt' => 'b',
+            'memory://dir/c.txt' => 'c',
+            'memory://dir/d.txt' => 'd',
+            'memory://dir/e.txt' => 'e',
+        ]))
+            ->withBatchSize(2)
+            ->scan(flow_context(), new FileScan(conjuncts: [ref('base_name')->isIn(lit(['c.txt', 'd.txt']))])), false);
+
+        static::assertCount(1, $batches);
+        static::assertSame(['c.txt', 'd.txt'], $batches[0]->column('base_name')->values());
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/FlowPhpExtensionTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/FlowPhpExtensionTest.php
index 1ecd4d604a..25f21489dc 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/FlowPhpExtensionTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/FlowPhpExtensionTest.php
@@ -26,7 +26,7 @@ public function test_a_loaded_extension_of_another_abi_is_refused(): void
     {
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage(
-            'The loaded flow_php extension (0.46.0, ABI 2) does not match flow-php/etl (ABI 1). Rebuild or upgrade '
+            'The loaded flow_php extension (0.46.0, ABI 3) does not match flow-php/etl (ABI 2). Rebuild or upgrade '
             . 'flow_php to the version of flow-php/etl, or stop loading it to use the PHP implementation.',
         );
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/BetweenTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/BetweenTest.php
index 17cf7fa38c..94c23fa6fb 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/BetweenTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/BetweenTest.php
@@ -12,11 +12,14 @@
 use Flow\Types\Exception\InvalidArgumentException as TypesInvalidArgumentException;
 
 use function Flow\ETL\DSL\between;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\lit;
 use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
+use function Flow\ETL\DSL\str_schema;
+use function Flow\Types\DSL\type_numeric_string;
 
 final class BetweenTest extends FlowTestCase
 {
@@ -165,4 +168,34 @@ public function test_between_refuses_incomparable_bounds_at_bind(): void
             ->between(lit(1), lit(new DateTimeImmutable('2024-01-01')))
             ->returns();
     }
+
+    public function test_between_orders_strings_by_bytes(): void
+    {
+        static::assertTrue((new FunctionContext(flow_context()))->eval(
+            ref('a')->between(lit('10'), lit('9')),
+            ['a' => '100'],
+            schema(str_schema('a')),
+        ));
+    }
+
+    public function test_between_orders_a_numeric_string_column_numerically(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->between(lit('10'), lit('9')),
+            ['a' => '100'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+        static::assertTrue((new FunctionContext($context))->eval(
+            ref('a')->between(lit('9'), lit('18446744073709551615'), lit(Boundary::INCLUSIVE)),
+            ['a' => '18446744073709551615'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->between(lit('9'), lit('18446744073709551614'), lit(Boundary::INCLUSIVE)),
+            ['a' => '18446744073709551615'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/ConjunctsTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/ConjunctsTest.php
new file mode 100644
index 0000000000..e96211fbf3
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/ConjunctsTest.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Function;
+
+use Flow\ETL\Function\All;
+use Flow\ETL\Function\Any;
+use Flow\ETL\Function\Conjuncts;
+use Flow\ETL\Tests\FlowTestCase;
+
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
+
+final class ConjunctsTest extends FlowTestCase
+{
+    public function test_a_function_that_is_not_an_and_is_its_only_conjunct(): void
+    {
+        $function = ref('id')->greaterThan(lit(1));
+
+        static::assertSame([$function], (new Conjuncts())->of($function));
+    }
+
+    public function test_a_nested_and_is_flattened(): void
+    {
+        $a = ref('a')->equals(lit(1));
+        $b = ref('b')->equals(lit(2));
+        $c = ref('c')->equals(lit(3));
+        $d = ref('d')->equals(lit(4));
+
+        static::assertSame([$a, $b, $c, $d], (new Conjuncts())->of(new All($a, new All($b, new All($c)), $d)));
+    }
+
+    public function test_an_or_is_kept_whole(): void
+    {
+        $a = ref('a')->equals(lit(1));
+        $or = new Any(ref('b')->equals(lit(2)), new All(ref('c')->equals(lit(3)), ref('d')->equals(lit(4))));
+
+        static::assertSame([$a, $or], (new Conjuncts())->of(new All($a, $or)));
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/Evaluation/FilterTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/Evaluation/FilterTest.php
new file mode 100644
index 0000000000..c46224a20a
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/Evaluation/FilterTest.php
@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Function\Evaluation;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Exception\SchemaDefinitionNotFoundException;
+use Flow\ETL\Function\Evaluation\Filter;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\ETL\Tests\Mother\ListColumnsMother;
+
+use function Flow\ETL\DSL\array_to_rows;
+use function Flow\ETL\DSL\config;
+use function Flow\ETL\DSL\flow_context;
+use function Flow\ETL\DSL\int_schema;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
+use function Flow\ETL\DSL\schema;
+
+final class FilterTest extends FlowTestCase
+{
+    public function test_no_predicate_keeps_the_same_rows(): void
+    {
+        $rows = array_to_rows([['a' => 1], ['a' => 2]], schema(int_schema('a')));
+
+        static::assertSame($rows, Filter::bind($rows->schema())->filter($rows, flow_context(config())));
+    }
+
+    public function test_empty_rows_stay_the_same_rows(): void
+    {
+        $rows = array_to_rows([], schema(int_schema('a')));
+
+        static::assertSame($rows, Filter::bind($rows->schema(), ref('a')->greaterThan(lit(0)))->filter(
+            $rows,
+            flow_context(config()),
+        ));
+    }
+
+    public function test_a_predicate_every_row_matches_keeps_the_same_rows(): void
+    {
+        $rows = array_to_rows([['a' => 1], ['a' => 2]], schema(int_schema('a')));
+
+        static::assertSame($rows, Filter::bind($rows->schema(), ref('a')->greaterThan(lit(0)))->filter(
+            $rows,
+            flow_context(config()),
+        ));
+    }
+
+    public function test_a_predicate_no_row_matches_keeps_no_row(): void
+    {
+        $rows = array_to_rows([['a' => 1], ['a' => 2]], schema(int_schema('a')));
+
+        static::assertSame(
+            0,
+            Filter::bind($rows->schema(), ref('a')->greaterThan(lit(5)))
+                ->filter($rows, flow_context(config()))
+                ->count(),
+        );
+    }
+
+    public function test_a_null_result_drops_the_row_as_false_does(): void
+    {
+        $rows = array_to_rows([['a' => 1], ['a' => null], ['a' => 3]], schema(int_schema('a', nullable: true)));
+
+        static::assertSame(
+            [['a' => 3]],
+            Filter::bind($rows->schema(), ref('a')->greaterThan(lit(1)))
+                ->filter($rows, flow_context(config()))
+                ->toArray(),
+        );
+    }
+
+    public function test_a_predicate_is_evaluated_only_on_the_rows_the_ones_before_it_kept(): void
+    {
+        $rows = array_to_rows([['a' => 0], ['a' => 2], ['a' => 10]], schema(int_schema('a')));
+
+        static::assertSame(
+            [['a' => 2]],
+            Filter::bind($rows->schema(), ref('a')->notEquals(lit(0)), lit(10)->divide(ref('a'))->greaterThan(lit(1)))
+                ->filter($rows, flow_context(config()))
+                ->toArray(),
+        );
+    }
+
+    public function test_a_reference_the_schema_lacks_is_refused(): void
+    {
+        $this->expectException(SchemaDefinitionNotFoundException::class);
+
+        Filter::bind(schema(int_schema('a')), ref('missing')->equals(lit(1)));
+    }
+
+    public function test_an_expanding_predicate_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'filter() cannot contain array_expand(), it turns one row into many rows. Expand with withEntry() first, then use the new column.',
+        );
+
+        Filter::bind(ListColumnsMother::schema(), ref('tags')->expand()->equals(lit('x')));
+    }
+
+    public function test_a_predicate_returning_no_boolean_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('filter() requires a predicate returning boolean');
+
+        Filter::bind(schema(int_schema('a')), ref('a'));
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanEqualTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanEqualTest.php
index 80daa88ae0..3cc7299f6b 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanEqualTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanEqualTest.php
@@ -11,6 +11,7 @@
 use Flow\Types\Exception\InvalidArgumentException;
 
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
@@ -22,6 +23,9 @@
 use function Flow\ETL\DSL\time_schema;
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
+use function Flow\Types\DSL\type_numeric_string;
+
+use const NAN;
 
 final class GreaterThanEqualTest extends FlowTestCase
 {
@@ -217,4 +221,45 @@ public function test_greater_than_equal_time_intervals(): void
             schema(time_schema('v')),
         ));
     }
+
+    public function test_greater_than_equal_orders_strings_by_bytes(): void
+    {
+        static::assertTrue((new FunctionContext(flow_context()))->eval(
+            ref('a')->greaterThanEqual(lit('10')),
+            ['a' => '9'],
+            schema(str_schema('a')),
+        ));
+    }
+
+    public function test_greater_than_equal_orders_a_numeric_string_column_numerically(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->greaterThanEqual(lit('10')),
+            ['a' => '9'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+        static::assertTrue((new FunctionContext($context))->eval(
+            ref('a')->greaterThanEqual(lit('18446744073709551614')),
+            ['a' => '18446744073709551615'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+    }
+
+    public function test_greater_than_equal_is_false_against_nan_in_either_direction(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->greaterThanEqual(lit(1.0)),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            lit(1.0)->greaterThanEqual(ref('a')),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanTest.php
index a5d92c5ab2..d66561daa4 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreaterThanTest.php
@@ -11,6 +11,7 @@
 use Flow\Types\Exception\InvalidArgumentException;
 
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
@@ -22,6 +23,9 @@
 use function Flow\ETL\DSL\time_schema;
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
+use function Flow\Types\DSL\type_numeric_string;
+
+use const NAN;
 
 final class GreaterThanTest extends FlowTestCase
 {
@@ -227,4 +231,45 @@ public function test_greater_than_time_intervals(): void
             schema(time_schema('v')),
         ));
     }
+
+    public function test_greater_than_orders_strings_by_bytes(): void
+    {
+        static::assertTrue((new FunctionContext(flow_context()))->eval(
+            ref('a')->greaterThan(lit('10')),
+            ['a' => '9'],
+            schema(str_schema('a')),
+        ));
+    }
+
+    public function test_greater_than_orders_a_numeric_string_column_numerically(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->greaterThan(lit('10')),
+            ['a' => '9'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+        static::assertTrue((new FunctionContext($context))->eval(
+            ref('a')->greaterThan(lit('18446744073709551614')),
+            ['a' => '18446744073709551615'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+    }
+
+    public function test_greater_than_is_false_against_nan_in_either_direction(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->greaterThan(lit(1.0)),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            lit(1.0)->greaterThan(ref('a')),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreatestTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreatestTest.php
index 8bf15b7382..81a1383fef 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreatestTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/GreatestTest.php
@@ -10,12 +10,15 @@
 use Flow\ETL\Tests\Context\FunctionContext;
 use Flow\ETL\Tests\FlowTestCase;
 
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\greatest;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\lit;
 use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
+use function Flow\ETL\DSL\str_schema;
+use function Flow\Types\DSL\type_numeric_string;
 
 final class GreatestTest extends FlowTestCase
 {
@@ -89,4 +92,22 @@ public function test_greatest_with_null(): void
             schema(int_schema('int')),
         ));
     }
+
+    public function test_greatest_orders_strings_by_bytes(): void
+    {
+        static::assertSame('9', (new FunctionContext(flow_context()))->eval(
+            greatest(ref('a'), lit('10'), lit('9')),
+            ['a' => null],
+            schema(str_schema('a', nullable: true)),
+        ));
+    }
+
+    public function test_greatest_orders_a_numeric_string_column_numerically(): void
+    {
+        static::assertSame('10', (new FunctionContext(flow_context()))->eval(
+            greatest(ref('a'), ref('b')),
+            ['a' => '9', 'b' => '10'],
+            schema(definition_from_type('a', type_numeric_string()), definition_from_type('b', type_numeric_string())),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LeastTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LeastTest.php
index dab159f076..63729cfb2d 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LeastTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LeastTest.php
@@ -10,12 +10,15 @@
 use Flow\ETL\Tests\Context\FunctionContext;
 use Flow\ETL\Tests\FlowTestCase;
 
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\least;
 use function Flow\ETL\DSL\lit;
 use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
+use function Flow\ETL\DSL\str_schema;
+use function Flow\Types\DSL\type_numeric_string;
 
 final class LeastTest extends FlowTestCase
 {
@@ -76,4 +79,22 @@ public function test_least_with_null(): void
             schema(int_schema('int')),
         ));
     }
+
+    public function test_least_orders_strings_by_bytes(): void
+    {
+        static::assertSame('10', (new FunctionContext(flow_context()))->eval(
+            least(ref('a'), lit('10'), lit('9')),
+            ['a' => null],
+            schema(str_schema('a', nullable: true)),
+        ));
+    }
+
+    public function test_least_orders_a_numeric_string_column_numerically(): void
+    {
+        static::assertSame('9', (new FunctionContext(flow_context()))->eval(
+            least(ref('a'), ref('b')),
+            ['a' => '9', 'b' => '10'],
+            schema(definition_from_type('a', type_numeric_string()), definition_from_type('b', type_numeric_string())),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanEqualTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanEqualTest.php
index 7f3b0d1620..2670ac50e0 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanEqualTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanEqualTest.php
@@ -11,6 +11,7 @@
 use Flow\Types\Exception\InvalidArgumentException;
 
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
@@ -22,6 +23,9 @@
 use function Flow\ETL\DSL\time_schema;
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
+use function Flow\Types\DSL\type_numeric_string;
+
+use const NAN;
 
 final class LessThanEqualTest extends FlowTestCase
 {
@@ -217,4 +221,45 @@ public function test_less_than_equal_time_intervals(): void
             schema(time_schema('v')),
         ));
     }
+
+    public function test_less_than_equal_orders_strings_by_bytes(): void
+    {
+        static::assertFalse((new FunctionContext(flow_context()))->eval(
+            ref('a')->lessThanEqual(lit('10')),
+            ['a' => '9'],
+            schema(str_schema('a')),
+        ));
+    }
+
+    public function test_less_than_equal_orders_a_numeric_string_column_numerically(): void
+    {
+        $context = flow_context();
+
+        static::assertTrue((new FunctionContext($context))->eval(
+            ref('a')->lessThanEqual(lit('10')),
+            ['a' => '9'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->lessThanEqual(lit('18446744073709551614')),
+            ['a' => '18446744073709551615'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+    }
+
+    public function test_less_than_equal_is_false_against_nan_in_either_direction(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->lessThanEqual(lit(1.0)),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            lit(1.0)->lessThanEqual(ref('a')),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanTest.php
index e24c88e4c0..d1c19da8f6 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/LessThanTest.php
@@ -11,6 +11,7 @@
 use Flow\Types\Exception\InvalidArgumentException;
 
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\flow_context;
 use function Flow\ETL\DSL\int_schema;
@@ -22,6 +23,9 @@
 use function Flow\ETL\DSL\time_schema;
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
+use function Flow\Types\DSL\type_numeric_string;
+
+use const NAN;
 
 final class LessThanTest extends FlowTestCase
 {
@@ -217,4 +221,45 @@ public function test_less_than_time_intervals(): void
             schema(time_schema('v')),
         ));
     }
+
+    public function test_less_than_orders_strings_by_bytes(): void
+    {
+        static::assertFalse((new FunctionContext(flow_context()))->eval(
+            ref('a')->lessThan(lit('10')),
+            ['a' => '9'],
+            schema(str_schema('a')),
+        ));
+    }
+
+    public function test_less_than_orders_a_numeric_string_column_numerically(): void
+    {
+        $context = flow_context();
+
+        static::assertTrue((new FunctionContext($context))->eval(
+            ref('a')->lessThan(lit('10')),
+            ['a' => '9'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->lessThan(lit('18446744073709551614')),
+            ['a' => '18446744073709551615'],
+            schema(definition_from_type('a', type_numeric_string())),
+        ));
+    }
+
+    public function test_less_than_is_false_against_nan_in_either_direction(): void
+    {
+        $context = flow_context();
+
+        static::assertFalse((new FunctionContext($context))->eval(
+            ref('a')->lessThan(lit(1.0)),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+        static::assertFalse((new FunctionContext($context))->eval(
+            lit(1.0)->lessThan(ref('a')),
+            ['a' => NAN],
+            schema(float_schema('a')),
+        ));
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/ValueOrderTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/ValueOrderTest.php
new file mode 100644
index 0000000000..2c63dd6110
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Function/ValueOrderTest.php
@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Function;
+
+use DateInterval;
+use DateTimeImmutable;
+use Flow\ETL\Function\ValueOrder;
+use Flow\ETL\Tests\FlowTestCase;
+use PHPUnit\Framework\Attributes\TestWith;
+
+use function Flow\Types\DSL\type_numeric_string;
+use function Flow\Types\DSL\type_optional;
+use function Flow\Types\DSL\type_string;
+
+use const NAN;
+
+final class ValueOrderTest extends FlowTestCase
+{
+    #[TestWith(['9', '10', 1])]
+    #[TestWith(['10', '9', -1])]
+    #[TestWith(['a', 'a', 0])]
+    #[TestWith(['B', 'a', -1])]
+    public function test_two_strings_order_by_bytes(string $left, string $right, int $expected): void
+    {
+        static::assertSame($expected, (new ValueOrder(type_string(), type_string()))->compare($left, $right));
+    }
+
+    #[TestWith(['9', '10', -1])]
+    #[TestWith(['18446744073709551615', '18446744073709551614', 1])]
+    #[TestWith(['100', '100', 0])]
+    public function test_a_numeric_string_operand_orders_strings_numerically(
+        string $left,
+        string $right,
+        int $expected,
+    ): void {
+        static::assertSame($expected, (new ValueOrder(type_optional(type_numeric_string()), type_string()))->compare(
+            $left,
+            $right,
+        ));
+    }
+
+    public function test_an_order_without_operand_types_orders_strings_by_bytes(): void
+    {
+        static::assertSame(1, (new ValueOrder())->compare('9', '10'));
+    }
+
+    public function test_numbers_order_as_php_compares_them(): void
+    {
+        $order = new ValueOrder();
+
+        static::assertSame(-1, $order->compare(1, 1.5));
+        static::assertSame(0, $order->compare(2, 2.0));
+        static::assertSame(1, $order->compare('5', 3));
+    }
+
+    public function test_nan_is_never_below_anything_in_either_direction(): void
+    {
+        $order = new ValueOrder();
+
+        static::assertSame(1, $order->compare(NAN, 1.0));
+        static::assertSame(1, $order->compare(1.0, NAN));
+    }
+
+    public function test_date_times_order_by_instant(): void
+    {
+        static::assertSame(-1, (new ValueOrder())->compare(
+            new DateTimeImmutable('2024-01-01 10:00:00+00:00'),
+            new DateTimeImmutable('2024-01-01 11:30:00+01:00'),
+        ));
+    }
+
+    public function test_intervals_order_by_length(): void
+    {
+        $order = new ValueOrder();
+
+        static::assertSame(-1, $order->compare(new DateInterval('PT59M'), new DateInterval('PT1H')));
+        static::assertSame(0, $order->compare(new DateInterval('PT60M'), new DateInterval('PT1H')));
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/FilterWalkTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/FilterWalkTest.php
index b1f9030bbf..1846332960 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/FilterWalkTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/FilterWalkTest.php
@@ -61,7 +61,7 @@ public function test_a_transparent_preserving_chain_reaches_the_leaf(): void
         $read = NodeMother::read();
 
         static::assertNotNull((new FilterWalk())->predicateAtLeaf(
-            new Filter(NodeMother::select($read), lit(true)),
+            new Filter(NodeMother::select($read, 'year'), lit(true)),
             $read,
             ref('year')->isNotNull(),
         ));
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/JoinSidesTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/JoinSidesTest.php
index 3da06e64ad..9cfc78dda3 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/JoinSidesTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/JoinSidesTest.php
@@ -18,17 +18,17 @@ public function test_a_node_that_is_not_a_join_is_returned_as_it_is(): void
     {
         $limit = NodeMother::limit(NodeMother::read(), 5);
 
-        static::assertSame($limit, (new JoinSides(Optimizer::default(), NodeMother::context()))->of($limit));
+        static::assertSame($limit, (new JoinSides(Optimizer::default(), NodeMother::context()))->of($limit, $limit));
     }
 
     public function test_a_joins_right_side_is_optimized_as_its_own_plan(): void
     {
         $join = NodeMother::join(NodeMother::read(), NodeMother::plan(NodeMother::limit(NodeMother::read(), 3))->root);
 
-        $rewritten = (new JoinSides(Optimizer::default(), NodeMother::context()))->of($join);
+        $rewritten = (new JoinSides(Optimizer::default(), NodeMother::context()))->of($join, $join);
 
         static::assertInstanceOf(Join::class, $rewritten);
-        static::assertSame(3, (new LogicalPlan($rewritten->right()))->source()->limit());
+        static::assertSame(3, (new LogicalPlan($rewritten->right()))->source()->scan()->limit);
         static::assertSame($join->children()[0], $rewritten->children()[0]);
     }
 
@@ -39,16 +39,16 @@ public function test_a_cross_joins_right_side_is_optimized_as_its_own_plan(): vo
             NodeMother::plan(NodeMother::limit(NodeMother::read(), 3))->root,
         );
 
-        $rewritten = (new JoinSides(Optimizer::default(), NodeMother::context()))->of($join);
+        $rewritten = (new JoinSides(Optimizer::default(), NodeMother::context()))->of($join, $join);
 
         static::assertInstanceOf(CrossJoin::class, $rewritten);
-        static::assertSame(3, (new LogicalPlan($rewritten->right()))->source()->limit());
+        static::assertSame(3, (new LogicalPlan($rewritten->right()))->source()->scan()->limit);
     }
 
     public function test_a_join_whose_right_side_does_not_change_keeps_its_identity(): void
     {
         $join = NodeMother::crossJoin(NodeMother::read(), NodeMother::plan(NodeMother::read())->root);
 
-        static::assertSame($join, (new JoinSides(new Optimizer(), NodeMother::context()))->of($join));
+        static::assertSame($join, (new JoinSides(new Optimizer(), NodeMother::context()))->of($join, $join));
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/CountFromStatisticsTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/CountFromStatisticsTest.php
index 1c8079b83b..9e4cafef44 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/CountFromStatisticsTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/CountFromStatisticsTest.php
@@ -9,6 +9,7 @@
 use Flow\ETL\Extractor\Statistics;
 use Flow\ETL\Memory\ArrayMemory;
 use Flow\ETL\Optimizer\Rule\CountFromStatistics;
+use Flow\ETL\Plan\Node\Read;
 use Flow\ETL\Plan\Trigger;
 use Flow\ETL\Tests\Double\DeclaringExtractor;
 use Flow\ETL\Tests\FlowTestCase;
@@ -130,10 +131,62 @@ public function test_a_read_with_a_pushed_limit_is_counted_by_running(): void
         static::assertSame($plan, (new CountFromStatistics())->apply($plan, NodeMother::context()));
     }
 
-    public function test_a_read_with_a_pushed_partition_filter_is_counted_by_running(): void
+    public function test_a_parquet_read_of_exact_statistics_is_counted_from_them(): void
     {
-        $plan = Trigger::count->plan(NodeMother::read()->withPathFilter(new RejectingFilter()));
+        $memory = memory_filesystem();
+        df()
+            ->read(from_sequence_number('id', 1, 25))
+            ->write(to_parquet(path('memory://count/file.parquet'), filesystem: $memory))
+            ->run();
+        $plan = Trigger::count->plan(new Read(from_parquet(path('memory://count/file.parquet'), filesystem: $memory)));
+
+        static::assertNotSame($plan, (new CountFromStatistics())->apply($plan, NodeMother::context()));
+    }
+
+    public function test_a_read_with_a_pushed_path_filter_is_counted_by_running(): void
+    {
+        $memory = memory_filesystem();
+        df()
+            ->read(from_sequence_number('id', 1, 25))
+            ->write(to_parquet(path('memory://count/file.parquet'), filesystem: $memory))
+            ->run();
+        $plan = Trigger::count->plan((new Read(from_parquet(
+            path('memory://count/file.parquet'),
+            filesystem: $memory,
+        )))->withPathFilter(new RejectingFilter()));
+
+        static::assertSame($plan, (new CountFromStatistics())->apply($plan, NodeMother::context()));
+    }
+
+    public function test_a_read_with_a_pushed_filter_is_counted_by_running(): void
+    {
+        $memory = memory_filesystem();
+        df()
+            ->read(from_sequence_number('id', 1, 25))
+            ->write(to_parquet(path('memory://count/file.parquet'), filesystem: $memory))
+            ->run();
+        $plan = Trigger::count->plan((new Read(from_parquet(
+            path('memory://count/file.parquet'),
+            filesystem: $memory,
+        )))->withFilter(ref('id')->greaterThan(lit(20))));
+
+        static::assertSame($plan, (new CountFromStatistics())->apply($plan, NodeMother::context()));
+    }
+
+    public function test_a_count_over_a_filtered_parquet_read_is_counted_by_running(): void
+    {
+        $memory = memory_filesystem();
+        df()
+            ->read(from_sequence_number('id', 1, 25))
+            ->write(to_parquet(path('memory://count/file.parquet'), filesystem: $memory))
+            ->run();
+        $frame = df()
+            ->read(from_parquet(path('memory://count/file.parquet'), filesystem: $memory))
+            ->filter(ref('id')->greaterThan(lit(20)));
+
+        $plan = $frame->explain(Trigger::count)->logical;
 
+        static::assertSame(5, $frame->count());
         static::assertSame($plan, (new CountFromStatistics())->apply($plan, NodeMother::context()));
     }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushFilterIntoSourceTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushFilterIntoSourceTest.php
index 7c55ab75b5..7849c68f54 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushFilterIntoSourceTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushFilterIntoSourceTest.php
@@ -6,9 +6,12 @@
 
 use DateTimeImmutable;
 use Flow\ETL\Exception\EvaluationException;
+use Flow\ETL\Exception\SchemaDefinitionNotFoundException;
+use Flow\ETL\Function\All;
 use Flow\ETL\Memory\ArrayMemory;
 use Flow\ETL\Optimizer;
 use Flow\ETL\Optimizer\Rule\PushFilterIntoSource;
+use Flow\ETL\Plan\Node;
 use Flow\ETL\Plan\Node\Filter;
 use Flow\ETL\Plan\Node\Read;
 use Flow\ETL\Plan\Stage;
@@ -21,6 +24,7 @@
 use Flow\ETL\WithEntry;
 use Flow\Filesystem\Path\Filter\Filters;
 use Flow\Filesystem\Path\Filter\OnlyFiles;
+use PHPUnit\Framework\Attributes\DataProvider;
 
 use function Flow\ETL\DSL\array_to_rows;
 use function Flow\ETL\DSL\df;
@@ -45,11 +49,11 @@ public function test_a_partition_only_predicate_is_pushed_into_the_source(): voi
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertInstanceOf(Filters::class, $pathFilter);
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
-        // the double reads every partition anyway, so only the Filter node the rule kept drops 2024
+        // the double lists every partition, so only the scan's filter drops 2024
         static::assertSame([2023], $rows->reduceToArray('year'));
     }
 
@@ -63,7 +67,7 @@ public function test_two_stacked_partition_filters_are_both_pushed(): void
             ->filter(ref('month')->equals(lit('07')))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=08')));
@@ -80,7 +84,7 @@ public function test_three_stacked_partition_filters_all_reach_the_source(): voi
             ->filter(ref('month')->equals(lit('07')))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2022/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
@@ -97,38 +101,53 @@ public function test_a_body_predicate_below_a_partition_filter_does_not_block_it
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
         static::assertSame(['a'], $rows->reduceToArray('value'));
     }
 
-    public function test_a_body_column_predicate_is_not_pushed(): void
+    public function test_a_body_column_predicate_is_pushed_as_a_filter_and_never_as_a_path_filter(): void
     {
         $extractor = PartitionedSourceMother::yearMonth();
 
         df()
             ->read($extractor)
-            ->filter(ref('value')->equals(lit('a')))
+            ->filter($predicate = ref('value')->equals(lit('a')))
+            ->fetch();
+
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
+        static::assertSame([$predicate], $extractor->scans[0]->conjuncts);
+    }
+
+    public function test_a_predicate_referencing_no_column_is_pushed_as_a_filter_and_never_as_a_path_filter(): void
+    {
+        $extractor = PartitionedSourceMother::yearMonth();
+
+        df()
+            ->read($extractor)
+            ->filter($predicate = lit(1)->equals(lit(1)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
+        static::assertSame([$predicate], $extractor->scans[0]->conjuncts);
     }
 
-    public function test_a_mixed_predicate_pushes_only_its_partition_conjunct(): void
+    public function test_a_mixed_predicate_pushes_both_conjuncts_and_only_the_partition_one_as_a_path_filter(): void
     {
         $extractor = PartitionedSourceMother::yearMonth();
 
         $rows = df()
             ->read($extractor)
-            ->filter(ref('year')->equals(lit(2023))->and(ref('value')->notEquals(lit('a'))))
+            ->filter(($year = ref('year')->equals(lit(2023)))->and($value = ref('value')->notEquals(lit('a'))))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertInstanceOf(Filters::class, $pathFilter);
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
-        // the body conjunct still runs in the Filter node: the only 2023 row has value "a"
+        static::assertEquals([$year, $value], $extractor->scans[0]->conjuncts);
+        // the scan applies the body conjunct too: the only 2023 row has value "a"
         static::assertCount(0, $rows);
     }
 
@@ -146,7 +165,7 @@ public function test_a_mixed_predicate_with_two_partition_conjuncts_pushes_both(
             )
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=08')));
@@ -165,7 +184,7 @@ public function test_a_conjunct_that_is_not_deterministic_is_skipped_and_the_res
             )
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
     }
@@ -179,22 +198,23 @@ public function test_an_or_over_partition_columns_is_pushed_whole(): void
             ->filter(ref('year')->equals(lit(2023))->or(ref('year')->equals(lit(2024))))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2025/month=07')));
     }
 
-    public function test_an_or_mixing_a_body_column_is_not_pushed(): void
+    public function test_an_or_mixing_a_body_column_is_pushed_whole_as_a_filter_and_never_as_a_path_filter(): void
     {
         $extractor = PartitionedSourceMother::yearMonth();
 
         df()
             ->read($extractor)
-            ->filter(ref('year')->equals(lit(2023))->or(ref('value')->equals(lit('x'))))
+            ->filter($predicate = ref('year')->equals(lit(2023))->or(ref('value')->equals(lit('x'))))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
+        static::assertSame([$predicate], $extractor->scans[0]->conjuncts);
     }
 
     public function test_a_nested_and_inside_an_and_pushes_the_partition_conjuncts(): void
@@ -211,7 +231,7 @@ public function test_a_nested_and_inside_an_and_pushes_the_partition_conjuncts()
             )
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=08')));
@@ -228,7 +248,7 @@ public function test_a_limit_below_the_filter_blocks_the_push(): void
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
     }
 
     public function test_a_with_entry_redefining_the_partition_column_blocks_the_push(): void
@@ -241,7 +261,7 @@ public function test_a_with_entry_redefining_the_partition_column_blocks_the_pus
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
     }
 
     public function test_a_duplicate_row_defining_the_partition_column_blocks_the_push(): void
@@ -254,7 +274,7 @@ public function test_a_duplicate_row_defining_the_partition_column_blocks_the_pu
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
         // the 2024 row's duplicate carries year=2023: pruning its partition would lose it
         static::assertCount(3, $rows);
     }
@@ -269,7 +289,7 @@ public function test_a_duplicate_row_defining_another_column_does_not_block_the_
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        static::assertInstanceOf(Filters::class, $extractor->pathFilters[0]);
+        static::assertInstanceOf(Filters::class, $extractor->scans[0]->pathFilter);
     }
 
     public function test_a_filter_a_sink_root_does_not_consume_through_is_not_pushed(): void
@@ -282,7 +302,7 @@ public function test_a_filter_a_sink_root_does_not_consume_through_is_not_pushed
             ->filter(ref('year')->equals(lit(2023)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
     }
 
     public function test_a_non_file_extractor_is_never_pushed_into(): void
@@ -294,7 +314,7 @@ public function test_a_non_file_extractor_is_never_pushed_into(): void
         static::assertSame($plan, (new PushFilterIntoSource())->apply($plan, NodeMother::context()));
     }
 
-    public function test_a_source_without_partition_columns_is_never_pushed_into(): void
+    public function test_a_data_conjunct_is_pushed_into_a_source_without_partition_columns(): void
     {
         $extractor = new RecordingFileExtractor(
             schema(int_schema('year')),
@@ -303,10 +323,37 @@ public function test_a_source_without_partition_columns_is_never_pushed_into():
 
         df()
             ->read($extractor)
-            ->filter(ref('year')->equals(lit(2023)))
+            ->filter($predicate = ref('year')->equals(lit(2023)))
+            ->fetch();
+
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
+        static::assertSame([$predicate], $extractor->scans[0]->conjuncts);
+    }
+
+    public function test_a_non_deterministic_data_conjunct_is_not_pushed(): void
+    {
+        $extractor = PartitionedSourceMother::yearMonth();
+
+        df()
+            ->read($extractor)
+            ->filter(ref('value')->equals(random_string(2)))
+            ->fetch();
+
+        static::assertSame([], $extractor->scans[0]->conjuncts);
+    }
+
+    public function test_a_data_conjunct_under_a_reducing_node_is_not_pushed(): void
+    {
+        $extractor = PartitionedSourceMother::yearMonth();
+
+        df()
+            ->read($extractor)
+            ->limit(5)
+            ->filter(ref('value')->equals(lit('a')))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertSame(5, $extractor->scans[0]->limit);
+        static::assertSame([], $extractor->scans[0]->conjuncts);
     }
 
     public function test_a_non_deterministic_predicate_is_not_pushed(): void
@@ -318,7 +365,7 @@ public function test_a_non_deterministic_predicate_is_not_pushed(): void
             ->filter(ref('month')->equals(random_string(2)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
     }
 
     public function test_a_predicate_calling_a_user_callable_is_not_pushed(): void
@@ -330,16 +377,26 @@ public function test_a_predicate_calling_a_user_callable_is_not_pushed(): void
             ->filter(ref('year')->call(lit('is_string'), type_boolean()))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
     }
 
-    public function test_a_literal_only_predicate_is_not_pushed(): void
+    public function test_a_constant_conjunct_is_pushed_and_stops_nothing_above_it(): void
     {
         $extractor = PartitionedSourceMother::yearMonth();
 
-        df()->read($extractor)->filter(lit(true))->fetch();
+        $rows = df()
+            ->read($extractor)
+            ->filter($constant = lit(true))
+            ->filter($year = ref('year')->equals(lit(2023)))
+            ->fetch();
+
+        static::assertSame([$constant, $year], $extractor->scans[0]->conjuncts);
+        static::assertSame([2023], $rows->reduceToArray('year'));
+    }
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+    public function test_a_constant_false_conjunct_returns_no_row(): void
+    {
+        static::assertSame(0, df()->read(PartitionedSourceMother::yearMonth())->filter(lit(false))->fetch()->count());
     }
 
     public function test_a_filter_inside_a_joined_frame_is_pushed_with_that_frames_context(): void
@@ -351,7 +408,7 @@ public function test_a_filter_inside_a_joined_frame_is_pushed_with_that_frames_c
             ->join(df()->read($right)->filter(ref('year')->equals(lit(2023))), join_on(['id' => 'year'], 'r_'))
             ->fetch();
 
-        $pathFilter = $right->pathFilters[0];
+        $pathFilter = $right->scans[0]->pathFilter;
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
     }
@@ -379,7 +436,7 @@ public function test_the_extractor_instance_is_never_mutated(): void
             $frame->explain()->toString(Stage::unoptimized),
         );
         static::assertStringEndsWith(
-            "Extractor: RecordingFileExtractor\n         Source: file:///dev/null\n         Files: Filters",
+            "Extractor: RecordingFileExtractor\n      Source: file:///dev/null\n      Files: Filters\n      Filter: Equals",
             $frame->explain()->toString(),
         );
     }
@@ -394,7 +451,7 @@ public function test_a_filter_on_a_renamed_partition_column_is_pushed_as_the_ori
             ->filter(ref('y')->equals(lit(2023)))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertInstanceOf(Filters::class, $pathFilter);
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
@@ -411,23 +468,228 @@ public function test_a_filter_on_an_alias_of_a_partition_column_is_pushed_as_the
             ->filter(ref('y')->equals(lit(2023)))
             ->fetch();
 
-        $pathFilter = $extractor->pathFilters[0];
+        $pathFilter = $extractor->scans[0]->pathFilter;
         static::assertInstanceOf(Filters::class, $pathFilter);
         static::assertTrue($pathFilter->accept(PartitionedSourceMother::file('year=2023/month=07')));
         static::assertFalse($pathFilter->accept(PartitionedSourceMother::file('year=2024/month=07')));
         static::assertSame([2023], $rows->reduceToArray('y'));
     }
 
-    public function test_a_filter_on_an_alias_of_a_body_column_is_not_pushed(): void
+    public function test_a_filter_on_an_alias_of_a_body_column_is_pushed_as_the_original_column_and_never_as_a_path_filter(): void
     {
         $extractor = PartitionedSourceMother::yearMonth();
 
         df()
             ->read($extractor)
             ->withEntry('v', ref('value'))
-            ->filter(ref('v')->equals(lit('a')))
+            ->filter(ref('v')->equals($literal = lit('a')))
+            ->fetch();
+
+        static::assertEquals(new OnlyFiles(), $extractor->scans[0]->pathFilter);
+        static::assertEquals([ref('value')->equals($literal)], $extractor->scans[0]->conjuncts);
+    }
+
+    public function test_a_filter_node_whose_only_conjunct_is_pushed_is_removed(): void
+    {
+        $plan = NodeMother::plan(
+            new Filter(new Read(PartitionedSourceMother::yearMonth()), $year = ref('year')->equals(lit(2023))),
+        );
+
+        $read = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Read::class, $read);
+        static::assertSame([$year], $read->scan()->conjuncts);
+    }
+
+    public function test_a_pushed_conjunct_leaves_its_filter_node_and_the_rest_stays_in_it(): void
+    {
+        $plan = NodeMother::plan(
+            new Filter(
+                new Read(PartitionedSourceMother::yearMonth()),
+                ($year = ref('year')->equals(lit(2023)))->and($random = ref('value')->equals(random_string(2))),
+            ),
+        );
+
+        $filter = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Filter::class, $filter);
+        static::assertSame($random, $filter->function);
+        $read = $filter->children()[0];
+        static::assertInstanceOf(Read::class, $read);
+        static::assertSame([$year], $read->scan()->conjuncts);
+    }
+
+    public function test_stacked_filter_nodes_are_pushed_leaf_first(): void
+    {
+        $plan = NodeMother::plan(
+            new Filter(
+                new Filter(new Read(PartitionedSourceMother::yearMonth()), $year = ref('year')->equals(lit(2023))),
+                $month = ref('month')->equals(lit('07')),
+            ),
+        );
+
+        $read = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Read::class, $read);
+        static::assertEquals([$year, $month], $read->scan()->conjuncts);
+    }
+
+    public function test_a_filter_node_that_keeps_a_conjunct_stops_the_push_of_the_filters_above_it(): void
+    {
+        $plan = NodeMother::plan(
+            new Filter(
+                new Filter(
+                    new Read(PartitionedSourceMother::yearMonth()),
+                    ($year = ref('year')->equals(lit(2023)))->and($random = ref('value')->equals(random_string(2))),
+                ),
+                $month = ref('month')->equals(lit('07')),
+            ),
+        );
+
+        $top = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Filter::class, $top);
+        static::assertSame($month, $top->function);
+        $bottom = $top->children()[0];
+        static::assertInstanceOf(Filter::class, $bottom);
+        static::assertSame($random, $bottom->function);
+        $read = $bottom->children()[0];
+        static::assertInstanceOf(Read::class, $read);
+        static::assertSame([$year], $read->scan()->conjuncts);
+    }
+
+    public function test_a_filter_node_keeping_two_conjuncts_keeps_them_as_one_all(): void
+    {
+        $plan = NodeMother::plan(
+            new Filter(
+                new Read(PartitionedSourceMother::yearMonth()),
+                ref('year')
+                    ->equals(lit(2023))
+                    ->and($first = ref('value')->equals(random_string(2)))
+                    ->and($second = ref('value')->notEquals(random_string(3))),
+            ),
+        );
+
+        $filter = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Filter::class, $filter);
+        static::assertEquals(new All($first, $second), $filter->function);
+    }
+
+    public function test_a_limit_above_a_fully_pushed_filter_is_pushed_beside_it(): void
+    {
+        $extractor = PartitionedSourceMother::yearMonth();
+
+        $rows = df()
+            ->read($extractor)
+            ->filter($year = ref('year')->equals(lit(2023)))
+            ->limit(1)
+            ->fetch();
+
+        static::assertSame(1, $extractor->scans[0]->limit);
+        static::assertSame([$year], $extractor->scans[0]->conjuncts);
+        static::assertSame([2023], $rows->reduceToArray('year'));
+    }
+
+    public function test_a_limit_above_a_filter_node_that_keeps_a_conjunct_is_not_pushed(): void
+    {
+        $extractor = PartitionedSourceMother::yearMonth();
+
+        df()
+            ->read($extractor)
+            ->filter(ref('year')->equals(lit(2023))->and(ref('value')->equals(random_string(2))))
+            ->limit(1)
+            ->fetch();
+
+        static::assertNull($extractor->scans[0]->limit);
+    }
+
+    public function test_a_kept_conjunct_keeps_every_conjunct_after_it_in_its_node(): void
+    {
+        $plan = NodeMother::plan(
+            new Filter(
+                new Read(PartitionedSourceMother::yearMonth()),
+                ($year = ref('year')->equals(lit(2023)))->and($random = ref('value')->equals(random_string(2)))->and(
+                    $month = ref('month')->equals(lit('07')),
+                ),
+            ),
+        );
+
+        $filter = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Filter::class, $filter);
+        static::assertEquals(new All($random, $month), $filter->function);
+        $read = $filter->children()[0];
+        static::assertInstanceOf(Read::class, $read);
+        static::assertSame([$year], $read->scan()->conjuncts);
+    }
+
+    /**
+     * @return iterable<string, array{Node}>
+     */
+    public static function nodes_removing_year(): iterable
+    {
+        $read = new Read(PartitionedSourceMother::yearMonth());
+
+        yield 'rename' => [new Node\Rename($read, 'year', 'y')];
+        yield 'drop' => [new Node\Drop($read, ['year'])];
+        yield 'select' => [new Node\Select($read, ['month', 'value'])];
+    }
+
+    #[DataProvider('nodes_removing_year')]
+    public function test_a_filter_on_a_column_a_node_removes_is_not_pushed_past_it(Node $node): void
+    {
+        $plan = NodeMother::plan(new Filter($node, $year = ref('year')->equals(lit(2023))));
+
+        $filter = (new PushFilterIntoSource())->apply($plan, NodeMother::context())->root->children()[0];
+
+        static::assertInstanceOf(Filter::class, $filter);
+        static::assertSame($year, $filter->function);
+    }
+
+    public function test_a_filter_on_a_renamed_away_column_fails(): void
+    {
+        $this->expectException(SchemaDefinitionNotFoundException::class);
+
+        df()
+            ->read(PartitionedSourceMother::yearMonth())
+            ->rename('year', 'y')
+            ->filter(ref('year')->equals(lit(2023)))
+            ->fetch();
+    }
+
+    public function test_a_filter_on_a_dropped_column_fails(): void
+    {
+        $this->expectException(SchemaDefinitionNotFoundException::class);
+
+        df()
+            ->read(PartitionedSourceMother::yearMonth())
+            ->drop('year')
+            ->filter(ref('year')->equals(lit(2023)))
+            ->fetch();
+    }
+
+    public function test_a_filter_on_a_column_select_does_not_keep_fails(): void
+    {
+        $this->expectException(SchemaDefinitionNotFoundException::class);
+
+        df()
+            ->read(PartitionedSourceMother::yearMonth())
+            ->select('month')
+            ->filter(ref('year')->equals(lit(2023)))
+            ->fetch();
+    }
+
+    public function test_a_filter_on_a_column_select_keeps_is_pushed(): void
+    {
+        $extractor = PartitionedSourceMother::yearMonth();
+
+        df()
+            ->read($extractor)
+            ->select('year')
+            ->filter($year = ref('year')->equals(lit(2023)))
             ->fetch();
 
-        static::assertEquals(new OnlyFiles(), $extractor->pathFilters[0]);
+        static::assertSame([$year], $extractor->scans[0]->conjuncts);
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushLimitIntoSourceTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushLimitIntoSourceTest.php
index e72ba207dc..579ddaa477 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushLimitIntoSourceTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/Rule/PushLimitIntoSourceTest.php
@@ -42,7 +42,7 @@ public function test_a_limit_directly_above_the_read_is_pushed(): void
             NodeMother::context(),
         );
 
-        static::assertSame(10, $plan->source()->limit());
+        static::assertSame(10, $plan->source()->scan()->limit);
     }
 
     public function test_a_limit_passes_a_select(): void
@@ -52,7 +52,7 @@ public function test_a_limit_passes_a_select(): void
             NodeMother::context(),
         );
 
-        static::assertSame(10, $plan->source()->limit());
+        static::assertSame(10, $plan->source()->scan()->limit);
     }
 
     #[DataProvider('expanding_expressions')]
@@ -63,7 +63,7 @@ public function test_a_limit_does_not_pass_an_expand_column(ScalarFunction $func
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public static function expanding_expressions(): Generator
@@ -82,7 +82,7 @@ public function test_a_limit_does_not_pass_a_filter(): void
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public function test_a_limit_does_not_pass_a_write(): void
@@ -92,7 +92,7 @@ public function test_a_limit_does_not_pass_a_write(): void
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public function test_a_blocker_discards_the_limit_collected_above_it_and_the_walk_continues(): void
@@ -105,7 +105,7 @@ public function test_a_blocker_discards_the_limit_collected_above_it_and_the_wal
             NodeMother::context(),
         );
 
-        static::assertSame(5, $plan->source()->limit());
+        static::assertSame(5, $plan->source()->scan()->limit);
     }
 
     public function test_the_push_rewrites_the_leaf_and_keeps_the_spine(): void
@@ -120,10 +120,10 @@ public function test_the_push_rewrites_the_leaf_and_keeps_the_spine(): void
         static::assertInstanceOf(Node\Limit::class, $limit);
         static::assertSame(10, $limit->limit);
         static::assertInstanceOf(Node\Select::class, $limit->children()[0]);
-        static::assertSame(10, $pushed->source()->limit());
+        static::assertSame(10, $pushed->source()->scan()->limit);
         static::assertSame($extractor, $pushed->source()->extractor());
-        static::assertNull($plan->source()->limit());
-        static::assertSame([], $extractor->limits);
+        static::assertNull($plan->source()->scan()->limit);
+        static::assertSame([], $extractor->scans);
     }
 
     public function test_the_minimum_of_two_limits_is_pushed(): void
@@ -133,7 +133,7 @@ public function test_the_minimum_of_two_limits_is_pushed(): void
             NodeMother::context(),
         );
 
-        static::assertSame(3, $plan->source()->limit());
+        static::assertSame(3, $plan->source()->scan()->limit);
     }
 
     public function test_a_limit_narrows_an_already_pushed_limit(): void
@@ -143,7 +143,7 @@ public function test_a_limit_narrows_an_already_pushed_limit(): void
             NodeMother::context(),
         );
 
-        static::assertSame(4, $plan->source()->limit());
+        static::assertSame(4, $plan->source()->scan()->limit);
     }
 
     public function test_a_plan_without_a_limit_pushes_nothing(): void
@@ -153,7 +153,7 @@ public function test_a_plan_without_a_limit_pushes_nothing(): void
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public function test_a_row_input_chain_that_does_not_end_in_a_read_throws(): void
@@ -185,7 +185,7 @@ public function test_a_transaction_contributes_one_walk_per_child(): void
             NodeMother::context(),
         );
 
-        static::assertSame(3, $plan->source()->limit());
+        static::assertSame(3, $plan->source()->scan()->limit);
     }
 
     public function test_one_transaction_child_whose_walk_yields_no_limit_blocks_the_push(): void
@@ -207,7 +207,7 @@ public function test_one_transaction_child_whose_walk_yields_no_limit_blocks_the
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public function test_a_limit_below_a_sink_is_pushed(): void
@@ -219,7 +219,7 @@ public function test_a_limit_below_a_sink_is_pushed(): void
             NodeMother::context(),
         );
 
-        static::assertSame(3, $plan->source()->limit());
+        static::assertSame(3, $plan->source()->scan()->limit);
     }
 
     public function test_a_limit_above_a_sink_does_not_narrow_the_sink(): void
@@ -233,7 +233,7 @@ public function test_a_limit_above_a_sink_does_not_narrow_the_sink(): void
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public function test_the_widest_limit_of_every_root_is_pushed(): void
@@ -247,7 +247,7 @@ public function test_the_widest_limit_of_every_root_is_pushed(): void
             NodeMother::context(),
         );
 
-        static::assertSame(5, $plan->source()->limit());
+        static::assertSame(5, $plan->source()->scan()->limit);
     }
 
     public function test_a_sink_whose_walk_yields_no_limit_blocks_the_push(): void
@@ -267,7 +267,7 @@ public function test_a_sink_whose_walk_yields_no_limit_blocks_the_push(): void
             NodeMother::context(),
         );
 
-        static::assertNull($plan->source()->limit());
+        static::assertNull($plan->source()->scan()->limit);
     }
 
     public function test_the_push_reaches_the_sinks_through_the_shared_leaf(): void
@@ -289,6 +289,6 @@ public function test_a_limit_above_an_offset_pushes_the_limit_plus_the_offset():
             NodeMother::context(),
         );
 
-        static::assertSame(110, $plan->source()->limit());
+        static::assertSame(110, $plan->source()->scan()->limit);
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/TopNRewriteTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/TopNRewriteTest.php
index 053bafae5b..2985a2f83c 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/TopNRewriteTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Optimizer/TopNRewriteTest.php
@@ -21,14 +21,14 @@ public function test_a_node_that_is_not_a_limit_is_returned_as_is(): void
     {
         $sort = NodeMother::sort(NodeMother::read());
 
-        static::assertSame($sort, (new TopNRewrite())->of($sort));
+        static::assertSame($sort, (new TopNRewrite())->of($sort, $sort));
     }
 
     public function test_a_limit_over_anything_but_a_sort_is_returned_as_is(): void
     {
         $limit = NodeMother::limit(NodeMother::select(NodeMother::sort(NodeMother::read())), 5);
 
-        static::assertSame($limit, (new TopNRewrite())->of($limit));
+        static::assertSame($limit, (new TopNRewrite())->of($limit, $limit));
     }
 
     public function test_a_limit_over_a_sort_becomes_a_top_n_over_the_sorts_input_refs_and_limit(): void
@@ -36,7 +36,8 @@ public function test_a_limit_over_a_sort_becomes_a_top_n_over_the_sorts_input_re
         $read = NodeMother::read();
         $refs = refs(ref('id'));
 
-        $topN = (new TopNRewrite())->of(NodeMother::limit(new Sort($read, $refs), 5));
+        $limit = NodeMother::limit(new Sort($read, $refs), 5);
+        $topN = (new TopNRewrite())->of($limit, $limit);
 
         static::assertInstanceOf(TopN::class, $topN);
         static::assertSame([$read], $topN->children());
@@ -48,10 +49,8 @@ public function test_a_limit_over_any_sort_is_rewritten_and_keeps_the_pinned_alg
     {
         $algorithm = external_sort()->memoryLimit(Unit::fromMb(1));
 
-        $topN = (new TopNRewrite())->of(NodeMother::limit(
-            new Sort(NodeMother::read(), refs(ref('id')), $algorithm),
-            1_000_000,
-        ));
+        $limit = NodeMother::limit(new Sort(NodeMother::read(), refs(ref('id')), $algorithm), 1_000_000);
+        $topN = (new TopNRewrite())->of($limit, $limit);
 
         static::assertInstanceOf(TopN::class, $topN);
         static::assertSame($algorithm, $topN->algorithm);
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/OptimizerTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/OptimizerTest.php
index fa4487f34a..97075d094c 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/OptimizerTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/OptimizerTest.php
@@ -57,14 +57,14 @@ public function test_an_optimizer_without_rules_returns_the_plan_it_was_given():
         static::assertSame($plan, (new Optimizer())->optimize($plan, NodeMother::context()));
     }
 
-    public function test_default_registers_combine_limits_combine_sort_and_limit_push_limit_push_filter_then_count_from_statistics(): void
+    public function test_default_registers_combine_limits_combine_sort_and_limit_push_filter_push_limit_then_count_from_statistics(): void
     {
         static::assertSame(
             [
                 CombineLimits::class,
                 CombineSortAndLimit::class,
-                PushLimitIntoSource::class,
                 PushFilterIntoSource::class,
+                PushLimitIntoSource::class,
                 CountFromStatistics::class,
                 PushProjectionIntoExpand::class,
             ],
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/BoxLayoutTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/BoxLayoutTest.php
index ce9a262b2c..db4411c12d 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/BoxLayoutTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/BoxLayoutTest.php
@@ -118,7 +118,7 @@ public function test_a_middle_child_branches_off_the_same_line(): void
             ┌─────────────┴─────────────┐┌─────────────┴─────────────┐┌─────────────┴─────────────┐
             │          #1 Read          ││          #1 Read          ││         #4 Select         │
             │   ────────────────────    ││         (shared)          ││   ────────────────────    │
-            │ Extractor: ArrayExtractor ││                           ││        Columns: id        │
+            │ Extractor: ArrayExtractor ││                           ││      Keeps only: id       │
             └───────────────────────────┘└───────────────────────────┘└─────────────┬─────────────┘
                                                                       ┌─────────────┴─────────────┐
                                                                       │          #1 Read          │
@@ -138,9 +138,9 @@ public function test_long_text_wraps_and_a_word_longer_than_the_box_is_split():
             │       Rename: id →        │
             │ identifier_of_the_custome │
             │          r_order          │
-            │     Defines columns:      │
+            │     Changes columns:      │
             │ identifier_of_the_custome │
-            │          r_order          │
+            │        r_order, id        │
             └─────────────┬─────────────┘
             ┌─────────────┴─────────────┐
             │          #1 Read          │
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/DetailsTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/DetailsTest.php
index 44e7139c9f..d1bf62490f 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/DetailsTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/DetailsTest.php
@@ -16,6 +16,7 @@
 use Flow\ETL\Plan\Node\Filter;
 use Flow\ETL\Plan\Node\Join as JoinNode;
 use Flow\ETL\Plan\Node\Offset;
+use Flow\ETL\Plan\Node\Read;
 use Flow\ETL\Plan\Node\Rename;
 use Flow\ETL\Plan\Node\RenameEach;
 use Flow\ETL\Plan\Node\Result;
@@ -26,6 +27,7 @@
 use Flow\ETL\Plan\RequiredColumns;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\ETL\Tests\Mother\NodeMother;
+use Flow\ETL\Tests\Mother\PartitionedSourceMother;
 use Flow\Filesystem\Path\Filter\KeepAll;
 
 use function Flow\ETL\DSL\hash_join;
@@ -48,11 +50,23 @@ public function test_a_read_lists_its_extractor_only_when_nothing_was_pushed_int
         static::assertSame(['Extractor: ArrayExtractor'], (new Details())->lines(NodeMother::read()));
     }
 
-    public function test_a_read_lists_a_pushed_limit_and_file_filter(): void
+    public function test_a_read_lists_a_pushed_limit_file_filter_and_each_conjunct(): void
     {
         static::assertSame(
-            ['Extractor: ArrayExtractor', 'Limit: 3', 'Files: Filters'],
-            (new Details())->lines(NodeMother::read()->withLimit(3)->withPathFilter(new KeepAll())),
+            [
+                'Extractor: RecordingFileExtractor',
+                'Source: file:///dev/null',
+                'Limit: 3',
+                'Files: Filters',
+                'Filter: GreaterThan',
+                'Filter: IsNotNull',
+            ],
+            (new Details())->lines(
+                (new Read(PartitionedSourceMother::yearMonth()))
+                    ->withLimit(3)
+                    ->withPathFilter(new KeepAll())
+                    ->withFilter(ref('year')->greaterThan(lit(1))->and(ref('month')->isNotNull())),
+            ),
         );
     }
 
@@ -80,7 +94,7 @@ public function test_a_join_labels_its_type_and_condition(): void
                 'Left on: id',
                 'Right on: id',
                 'Buffers all rows before passing them on',
-                'Defines columns known only at run time',
+                'Changes columns known only at run time',
             ],
             (new Details())->lines(NodeMother::join(
                 NodeMother::read(),
@@ -171,12 +185,12 @@ public function test_redefined_columns_follow_the_labelled_details(): void
         $details = new Details();
 
         static::assertSame(
-            ['Column: n = Literal', 'Defines columns: n'],
+            ['Column: n = Literal', 'Changes columns: n'],
             $details->lines(new WithColumn($read, int_schema('n'), lit(1))),
         );
-        static::assertSame(['Rename: n → m', 'Defines columns: m'], $details->lines(new Rename($read, 'n', 'm')));
+        static::assertSame(['Rename: n → m', 'Changes columns: m, n'], $details->lines(new Rename($read, 'n', 'm')));
         static::assertSame(
-            ['Defines columns known only at run time'],
+            ['Changes columns known only at run time'],
             $details->lines(new RenameEach($read, [rename_replace('_', '-')])),
         );
     }
@@ -188,7 +202,7 @@ public function test_declarations_are_the_row_count_transparency_materialization
 
         static::assertSame('preserving · transparent · blocking', $details->declarations(new Collect($read)));
         static::assertSame(
-            'preserving · transparent · streaming · redefines m',
+            'preserving · transparent · streaming · redefines m, n',
             $details->declarations(new Rename($read, 'n', 'm')),
         );
         static::assertSame('preserving · transparent · streaming · redefines unknown', $details->declarations(
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/FlowLayoutTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/FlowLayoutTest.php
index b6650dea73..d1ad96ed9c 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/FlowLayoutTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/FlowLayoutTest.php
@@ -72,7 +72,7 @@ public function test_every_reader_of_a_node_hangs_under_it(): void
             ├─ #3 Write
             │     Loader: MemoryLoader
             └─ #4 Select
-               │  Columns: id
+               │  Keeps only: id
                └─ #5 Write
                      Loader: MemoryLoader
             PLAN, (new FlowLayout())->render((new Outline())->of($plan)));
@@ -89,7 +89,7 @@ public function test_every_source_starts_its_own_tree_and_a_node_reached_again_i
             │  Extractor: ArrayExtractor
             └─ #3 CrossJoin
                │  Type: cross
-               │  Defines columns known only at run time
+               │  Changes columns known only at run time
                └─ #4 Result
                      Rows this plan hands out: to the trigger, or to the node reading it
             #2 Read
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/PhysicalOutlineTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/PhysicalOutlineTest.php
index d8d612ddeb..77c2935cad 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/PhysicalOutlineTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/PhysicalOutlineTest.php
@@ -7,6 +7,7 @@
 use Flow\ETL\Dataset\Memory\Unit;
 use Flow\ETL\Plan\Explain\PhysicalOutline;
 use Flow\ETL\Plan\Explain\TreeLayout;
+use Flow\ETL\Tests\Double\RecordingFileExtractor;
 use Flow\ETL\Tests\Double\UndescribableRowLessExtractor;
 use Flow\ETL\Tests\FlowTestCase;
 use Flow\ETL\Tests\Mother\PhysicalPlanMother;
@@ -14,7 +15,11 @@
 use function Flow\ETL\DSL\data_frame;
 use function Flow\ETL\DSL\from_array;
 use function Flow\ETL\DSL\hash_join;
+use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\join_on;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
+use function Flow\ETL\DSL\schema;
 use function Flow\ETL\DSL\to_output;
 
 final class PhysicalOutlineTest extends FlowTestCase
@@ -112,6 +117,23 @@ public function test_a_pushed_limit_is_listed_under_the_source_that_was_handed_i
         );
     }
 
+    public function test_a_pushed_filter_is_listed_under_the_file_source_that_was_offered_it(): void
+    {
+        $root = (new PhysicalOutline())->of(PhysicalPlanMother::of(
+            data_frame()
+                ->read(new RecordingFileExtractor(schema(int_schema('id'))))
+                ->filter(ref('id')->greaterThan(lit(1))),
+        ));
+
+        static::assertSame(
+            [
+                'Extractor: RecordingFileExtractor',
+                '   Filter: GreaterThan',
+            ],
+            $root->children[0]->lines,
+        );
+    }
+
     public function test_a_plan_that_could_not_derive_its_schema_says_why(): void
     {
         $root = (new PhysicalOutline())->of(PhysicalPlanMother::reading(new UndescribableRowLessExtractor()));
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/TreeLayoutTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/TreeLayoutTest.php
index 3f51fdfc36..8c5991cf56 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/TreeLayoutTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Explain/TreeLayoutTest.php
@@ -91,7 +91,7 @@ public function test_every_child_but_the_last_keeps_the_rail_open(): void
             └─ #5 Write
                │  Loader: MemoryLoader
                └─ #4 Select
-                  │  Columns: id
+                  │  Keeps only: id
                   └─ #1 Read (shared)
             PLAN, (new TreeLayout())->render((new Outline())->of($plan)));
     }
@@ -105,8 +105,8 @@ public function test_with_declarations_a_single_chain_prints_one_line_per_node_w
             │  Rows this plan hands out: to the trigger, or to the node reading it
             └─ #3 Limit  reducing · transparent · streaming
                │  Limit: 5
-               └─ #2 Select  preserving · transparent · streaming
-                  │  Columns: id
+               └─ #2 Select  preserving · transparent · streaming · redefines all but id
+                  │  Keeps only: id
                   └─ #1 Read  source · transparent · streaming
                         Extractor: ArrayExtractor
             PLAN, (new TreeLayout())->render((new Outline(declarations: true))->of($plan->root)));
@@ -155,7 +155,7 @@ public function test_with_declarations_payloads_and_redefinitions(): void
                │  Until: Literal
                └─ #5 Offset  reducing · transparent · streaming
                   │  Skip: 2
-                  └─ #4 Rename  preserving · transparent · streaming · redefines m
+                  └─ #4 Rename  preserving · transparent · streaming · redefines m, n
                      │  Rename: n → m
                      └─ #3 WithColumn  preserving · transparent · streaming · redefines n
                         │  Column: n = Literal
@@ -202,8 +202,8 @@ public function test_with_declarations_a_run_trigger_keeps_a_result_beside_the_w
             Outputs  preserving · opaque · streaming
             ├─ #3 Result  preserving · transparent · streaming
             │  │  Rows this plan hands out: to the trigger, or to the node reading it
-            │  └─ #2 Select  preserving · transparent · streaming
-            │     │  Columns: id
+            │  └─ #2 Select  preserving · transparent · streaming · redefines all but id
+            │     │  Keeps only: id
             │     └─ #1 Read  source · transparent · streaming
             │           Extractor: ArrayExtractor
             └─ #4 Write  preserving · opaque · streaming
@@ -241,8 +241,8 @@ public function test_with_declarations_a_transaction_root_child_lists_its_writes
                │  └─ #1 Read (shared)
                └─ #5 Write  preserving · opaque · streaming
                   │  Loader: MemoryLoader
-                  └─ #4 Select  preserving · transparent · streaming
-                     │  Columns: id
+                  └─ #4 Select  preserving · transparent · streaming · redefines all but id
+                     │  Keeps only: id
                      └─ #1 Read (shared)
             PLAN, (new TreeLayout())->render((new Outline(declarations: true))->of($plan->root)));
     }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/LogicalPlanTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/LogicalPlanTest.php
index f3ba70577c..5c2f3c4cd7 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/LogicalPlanTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/LogicalPlanTest.php
@@ -13,7 +13,7 @@
 use Flow\ETL\Plan\Node\Result;
 use Flow\ETL\Plan\Node\Transaction;
 use Flow\ETL\Plan\Node\Write;
-use Flow\ETL\Plan\ReplaceLeaf;
+use Flow\ETL\Plan\ReplaceNodes;
 use Flow\ETL\Plan\Rewrite;
 use Flow\ETL\Tests\Double\ChildlessNode;
 use Flow\ETL\Tests\Double\RecordingTransaction;
@@ -107,12 +107,12 @@ public function test_consumer_inputs_include_the_inputs_of_sinks_below_the_root(
         static::assertSame([$select, $limit], NodeMother::plan($select)->consumerInputs());
     }
 
-    public function test_transform_up_with_replace_leaf_rewrites_the_leaf_and_keeps_the_spine(): void
+    public function test_transform_up_with_replace_nodes_rewrites_the_leaf_and_keeps_the_spine(): void
     {
         $replacement = NodeMother::read(from_array([['id' => 2]]));
         $plan = NodeMother::plan(NodeMother::select(NodeMother::read()));
 
-        $rewritten = $plan->transformUp(new ReplaceLeaf($plan->source(), $replacement));
+        $rewritten = $plan->transformUp(ReplaceNodes::one($plan->source(), $replacement));
 
         static::assertSame($replacement, $rewritten->source());
         $select = $rewritten->root->children()[0];
@@ -148,9 +148,9 @@ public function test_transform_up_refuses_an_outputs_consumer_rewritten_to_a_non
         );
 
         $plan->transformUp(new class implements Rewrite {
-            public function of(Node $node): Node
+            public function of(Node $original, Node $rebuilt): Node
             {
-                return $node instanceof Write ? $node->children()[0] : $node;
+                return $rebuilt instanceof Write ? $rebuilt->children()[0] : $rebuilt;
             }
         });
     }
@@ -186,9 +186,9 @@ public function test_transform_up_rebuilds_bottom_up(): void
         $plan = NodeMother::plan(NodeMother::limit(NodeMother::select($read), 5));
 
         $rewritten = $plan->transformUp(new class implements Rewrite {
-            public function of(Node $node): Node
+            public function of(Node $original, Node $rebuilt): Node
             {
-                return $node instanceof Limit ? new Limit($node->children()[0], 1) : $node;
+                return $rebuilt instanceof Limit ? new Limit($rebuilt->children()[0], 1) : $rebuilt;
             }
         });
 
@@ -205,9 +205,9 @@ public function test_transform_up_that_changes_nothing_returns_the_same_plan():
         $plan = NodeMother::plan(NodeMother::limit(NodeMother::select(NodeMother::read()), 5));
 
         $rewritten = $plan->transformUp(new class implements Rewrite {
-            public function of(Node $node): Node
+            public function of(Node $original, Node $rebuilt): Node
             {
-                return $node;
+                return $rebuilt;
             }
         });
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/DropTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/DropTest.php
index 494bd90af7..df0a4cb119 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/DropTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/DropTest.php
@@ -44,6 +44,6 @@ public function test_declarations(): void
         static::assertSame(RowCount::preserving, $node->rowCount());
         static::assertSame(Transparency::transparent, $node->transparency());
         static::assertSame(Materialization::streaming, $node->materialization());
-        static::assertEquals(Redefined::none(), $node->redefines());
+        static::assertEquals(Redefined::names('id'), $node->redefines());
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/ReadTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/ReadTest.php
index 459547604d..f120798b2e 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/ReadTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/ReadTest.php
@@ -5,18 +5,21 @@
 namespace Flow\ETL\Tests\Unit\Plan\Node;
 
 use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Plan\Materialization;
 use Flow\ETL\Plan\Node\Read;
 use Flow\ETL\Plan\Redefined;
 use Flow\ETL\Plan\RowCount;
 use Flow\ETL\Plan\Transparency;
 use Flow\ETL\Tests\FlowTestCase;
-use Flow\Filesystem\Path\Filter\Filters;
+use Flow\ETL\Tests\Mother\PartitionedSourceMother;
 use Flow\Filesystem\Path\Filter\OnlyFiles;
 use Flow\Filesystem\Tests\Double\RejectingFilter;
 
 use function Flow\ETL\DSL\from_array;
 use function Flow\ETL\DSL\int_schema;
+use function Flow\ETL\DSL\lit;
+use function Flow\ETL\DSL\ref;
 use function Flow\ETL\DSL\schema;
 
 final class ReadTest extends FlowTestCase
@@ -37,62 +40,74 @@ public function test_a_default_read_pushes_no_limit_and_lists_only_files(): void
     {
         $read = new Read(from_array([['id' => 1]]));
 
-        static::assertNull($read->limit());
-        static::assertInstanceOf(OnlyFiles::class, $read->pathFilter());
+        static::assertNull($read->scan()->limit);
+        static::assertInstanceOf(OnlyFiles::class, $read->scan()->pathFilter);
     }
 
-    public function test_extractor_limit_and_path_filter_are_the_values_it_was_built_with(): void
+    public function test_extractor_and_scan_are_the_values_it_was_built_with(): void
     {
         $extractor = from_array([['id' => 1]]);
-        $filter = new RejectingFilter();
+        $scan = new FileScan(5, new RejectingFilter());
 
-        $read = new Read($extractor, 5, $filter);
+        $read = new Read($extractor, $scan);
 
         static::assertSame($extractor, $read->extractor());
-        static::assertSame(5, $read->limit());
-        static::assertSame($filter, $read->pathFilter());
+        static::assertSame($scan, $read->scan());
     }
 
-    public function test_with_path_filter_composes_with_the_filters_already_held(): void
+    public function test_with_path_filter_and_with_filter_push_into_the_scan_and_leave_the_original_alone(): void
     {
-        $extractor = from_array([['id' => 1]]);
-        $read = new Read($extractor, 3);
-        $first = new RejectingFilter();
-        $second = new RejectingFilter();
+        $extractor = PartitionedSourceMother::yearMonth();
+        $read = new Read($extractor, new FileScan(3));
+        $pathFilter = new RejectingFilter();
+        $filter = ref('year')->greaterThan(lit(1));
 
-        $filtered = $read->withPathFilter($first)->withPathFilter($second);
+        $pushed = $read->withPathFilter($pathFilter)->withFilter($filter);
 
-        static::assertInstanceOf(OnlyFiles::class, $read->pathFilter());
-        static::assertEquals(new Filters(new OnlyFiles(), $first, $second), $filtered->pathFilter());
-        static::assertSame(3, $filtered->limit());
-        static::assertSame($extractor, $filtered->extractor());
+        static::assertEquals(new FileScan(3), $read->scan());
+        static::assertEquals(
+            (new FileScan(3))
+                ->withPathFilter($pathFilter)
+                ->withFilter($filter),
+            $pushed->scan(),
+        );
+        static::assertSame($extractor, $pushed->extractor());
     }
 
-    public function test_with_limit_returns_a_new_read_and_leaves_the_original_alone(): void
+    public function test_with_limit_pushes_into_the_scan_of_any_extractor(): void
     {
-        $read = (new Read(from_array([['id' => 1]])))->withPathFilter($filter = new OnlyFiles());
+        $read = new Read(from_array([['id' => 1]]));
 
-        $limited = $read->withLimit(5);
+        static::assertNull($read->scan()->limit);
+        static::assertSame(10, $read->withLimit(10)->withLimit(100)->scan()->limit);
+    }
+
+    public function test_with_limit_refuses_zero_or_less(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Limit must be greater than 0');
 
-        static::assertNull($read->limit());
-        static::assertSame(5, $limited->limit());
-        static::assertEquals(new Filters(new OnlyFiles(), $filter), $limited->pathFilter());
+        (new Read(from_array([['id' => 1]])))->withLimit(0);
     }
 
-    public function test_with_limit_narrows_and_never_widens(): void
+    public function test_a_filter_is_refused_for_an_extractor_that_is_no_file_extractor(): void
     {
-        $read = new Read(from_array([['id' => 1]]));
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Only a FileExtractor reads a pushed filter, Flow\ETL\Extractor\ArrayExtractor does not',
+        );
 
-        static::assertSame(10, $read->withLimit(10)->withLimit(100)->limit());
-        static::assertSame(10, $read->withLimit(100)->withLimit(10)->limit());
+        (new Read(from_array([['id' => 1]])))->withFilter(ref('id')->greaterThan(lit(1)));
     }
 
-    public function test_with_limit_refuses_zero_or_less(): void
+    public function test_a_path_filter_is_refused_for_an_extractor_that_is_no_file_extractor(): void
     {
         $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Limit must be greater than 0');
+        $this->expectExceptionMessage(
+            'Only a FileExtractor reads a pushed filter, Flow\ETL\Extractor\ArrayExtractor does not',
+        );
 
-        (new Read(from_array([['id' => 1]])))->withLimit(0);
+        (new Read(from_array([['id' => 1]])))->withPathFilter(new RejectingFilter());
     }
 
     public function test_schema_delegates_to_the_extractor(): void
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/RenameTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/RenameTest.php
index 5776bf92ca..72205a2f26 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/RenameTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/RenameTest.php
@@ -45,6 +45,6 @@ public function test_declarations(): void
         static::assertSame(RowCount::preserving, $node->rowCount());
         static::assertSame(Transparency::transparent, $node->transparency());
         static::assertSame(Materialization::streaming, $node->materialization());
-        static::assertEquals(Redefined::alias('user_id', 'id'), $node->redefines());
+        static::assertEquals(Redefined::rename('id', 'user_id'), $node->redefines());
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/SelectTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/SelectTest.php
index f934c68ef9..845480c535 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/SelectTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/Node/SelectTest.php
@@ -44,6 +44,6 @@ public function test_declarations(): void
         static::assertSame(RowCount::preserving, $node->rowCount());
         static::assertSame(Transparency::transparent, $node->transparency());
         static::assertSame(Materialization::streaming, $node->materialization());
-        static::assertEquals(Redefined::none(), $node->redefines());
+        static::assertEquals(Redefined::allBut('id'), $node->redefines());
     }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/RedefinedTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/RedefinedTest.php
index 21ddb51400..b5e0442dae 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/RedefinedTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/RedefinedTest.php
@@ -13,7 +13,8 @@ public function test_none_defines_nothing(): void
     {
         static::assertFalse(Redefined::none()->defines('year'));
         static::assertSame([], Redefined::none()->names);
-        static::assertFalse(Redefined::none()->unknown);
+        static::assertFalse(Redefined::none()->isUnknown());
+        static::assertFalse(Redefined::none()->isAllBut());
     }
 
     public function test_names_define_exactly_those_names_and_alias_none(): void
@@ -30,7 +31,8 @@ public function test_unknown_defines_every_name_and_aliases_none(): void
     {
         static::assertTrue(Redefined::unknown()->defines('anything'));
         static::assertNull(Redefined::unknown()->aliasOf('anything'));
-        static::assertTrue(Redefined::unknown()->unknown);
+        static::assertTrue(Redefined::unknown()->isUnknown());
+        static::assertFalse(Redefined::unknown()->isAllBut());
     }
 
     public function test_names_with_no_names_defines_nothing(): void
@@ -49,4 +51,27 @@ public function test_an_alias_defines_its_name_and_points_it_at_the_column_below
         static::assertNull($redefined->aliasOf('year'));
         static::assertSame(['y'], $redefined->names);
     }
+
+    public function test_all_but_defines_every_name_except_the_kept_ones(): void
+    {
+        $redefined = Redefined::allBut('year');
+
+        static::assertFalse($redefined->defines('year'));
+        static::assertTrue($redefined->defines('month'));
+        static::assertNull($redefined->aliasOf('month'));
+        static::assertSame(['year'], $redefined->names);
+        static::assertTrue($redefined->isAllBut());
+        static::assertFalse($redefined->isUnknown());
+    }
+
+    public function test_a_rename_defines_both_names_and_points_the_new_one_at_the_old_one(): void
+    {
+        $redefined = Redefined::rename('year', 'y');
+
+        static::assertTrue($redefined->defines('y'));
+        static::assertTrue($redefined->defines('year'));
+        static::assertSame('year', $redefined->aliasOf('y'));
+        static::assertNull($redefined->aliasOf('year'));
+        static::assertSame(['y', 'year'], $redefined->names);
+    }
 }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/ReplaceLeafTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/ReplaceLeafTest.php
deleted file mode 100644
index 720dace269..0000000000
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/ReplaceLeafTest.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Flow\ETL\Tests\Unit\Plan;
-
-use Flow\ETL\Plan\ReplaceLeaf;
-use Flow\ETL\Tests\FlowTestCase;
-use Flow\ETL\Tests\Mother\NodeMother;
-
-final class ReplaceLeafTest extends FlowTestCase
-{
-    public function test_the_target_node_is_replaced(): void
-    {
-        $target = NodeMother::read();
-        $replacement = NodeMother::read();
-
-        static::assertSame($replacement, (new ReplaceLeaf($target, $replacement))->of($target));
-    }
-
-    public function test_any_other_node_is_returned_unchanged(): void
-    {
-        $other = NodeMother::select(NodeMother::read());
-
-        static::assertSame($other, (new ReplaceLeaf(NodeMother::read(), NodeMother::read()))->of($other));
-    }
-}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/ReplaceNodesTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/ReplaceNodesTest.php
new file mode 100644
index 0000000000..3853d01c2f
--- /dev/null
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/ReplaceNodesTest.php
@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\Plan;
+
+use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Plan\Node;
+use Flow\ETL\Plan\Node\Filter;
+use Flow\ETL\Plan\ReplaceNodes;
+use Flow\ETL\Tests\FlowTestCase;
+use Flow\ETL\Tests\Mother\NodeMother;
+use SplObjectStorage;
+
+use function Flow\ETL\DSL\lit;
+
+final class ReplaceNodesTest extends FlowTestCase
+{
+    public function test_a_target_is_replaced_and_any_other_node_returned_as_rebuilt(): void
+    {
+        $target = NodeMother::read();
+        $replacement = NodeMother::read();
+        $other = NodeMother::select(NodeMother::read());
+        $rewrite = ReplaceNodes::one($target, $replacement);
+
+        static::assertSame($replacement, $rewrite->of($target, $target));
+        static::assertSame($other, $rewrite->of($other, $other));
+    }
+
+    public function test_a_replacement_takes_the_targets_rewritten_children(): void
+    {
+        $target = NodeMother::select(NodeMother::read());
+        $rebuilt = $target->withChildren([$read = NodeMother::read()]);
+
+        $replaced = ReplaceNodes::one($target, NodeMother::select($target->children()[0], 'name'))->of(
+            $target,
+            $rebuilt,
+        );
+
+        static::assertSame([$read], $replaced->children());
+    }
+
+    public function test_a_removed_node_gives_way_to_its_rewritten_child(): void
+    {
+        $target = new Filter(NodeMother::read(), lit(true));
+        $rebuilt = $target->withChildren([$read = NodeMother::read()]);
+
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
+
+        static::assertSame($read, (new ReplaceNodes($replacements, [$target]))->of($target, $rebuilt));
+    }
+
+    public function test_a_target_replaced_by_its_own_child_keeps_the_childs_rewritten_children(): void
+    {
+        $child = NodeMother::select(NodeMother::read());
+        $target = new Filter($child, lit(true));
+        $rebuilt = $target->withChildren([NodeMother::select(NodeMother::read())]);
+
+        static::assertSame($rebuilt->children(), ReplaceNodes::one($target, $child)->of($target, $rebuilt)->children());
+    }
+
+    public function test_a_node_of_other_than_one_child_is_not_removed(): void
+    {
+        $target = NodeMother::read();
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Only a node of one child gives way to it, ' . $target::class . ' has 0');
+
+        (new ReplaceNodes($replacements, [$target]))->of($target, $target);
+    }
+
+    public function test_a_node_both_replaced_and_removed_is_refused(): void
+    {
+        $target = new Filter(NodeMother::read(), lit(true));
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
+        $replacements[$target] = NodeMother::read();
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A node is either replaced or removed, ' . Filter::class . ' is both');
+
+        new ReplaceNodes($replacements, [$target]);
+    }
+
+    public function test_several_targets_are_replaced_in_one_rewrite(): void
+    {
+        $first = NodeMother::read();
+        $second = NodeMother::read();
+        /** @var SplObjectStorage<Node, Node> $replacements */
+        $replacements = new SplObjectStorage();
+        $replacements[$first] = $firstReplacement = NodeMother::read();
+        $replacements[$second] = $secondReplacement = NodeMother::read();
+        $rewrite = new ReplaceNodes($replacements);
+
+        static::assertSame($firstReplacement, $rewrite->of($first, $first));
+        static::assertSame($secondReplacement, $rewrite->of($second, $second));
+    }
+}
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/TransformUpTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/TransformUpTest.php
index 94628a6ba5..c74e53d68f 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/TransformUpTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Plan/TransformUpTest.php
@@ -34,11 +34,11 @@ public function __construct(
                 private array &$visited,
             ) {}
 
-            public function of(Node $node): Node
+            public function of(Node $original, Node $rebuilt): Node
             {
-                $this->visited[] = $node::class;
+                $this->visited[] = $rebuilt::class;
 
-                return $node;
+                return $rebuilt;
             }
         });
 
@@ -50,9 +50,9 @@ public function test_a_rewrite_that_changes_nothing_returns_the_same_root_object
         $root = NodeMother::limit(NodeMother::select(NodeMother::read()), 5);
 
         static::assertSame($root, (new TransformUp())->of($root, new class implements Rewrite {
-            public function of(Node $node): Node
+            public function of(Node $original, Node $rebuilt): Node
             {
-                return $node;
+                return $rebuilt;
             }
         }));
     }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Planner/PipelineSplitTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Planner/PipelineSplitTest.php
index 3ec9d45a48..62a19a2452 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Planner/PipelineSplitTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Planner/PipelineSplitTest.php
@@ -665,8 +665,8 @@ public function test_the_leaf_pipeline_carries_the_reads_limit_and_path_filter()
 
         $plan = (new PipelineSplit())->of($logical, $planned, NodeMother::context());
 
-        static::assertSame(5, $plan->root()->input()?->limit());
-        static::assertNull($plan->root()->limit());
+        static::assertSame(5, $plan->root()->input()?->scan()->limit);
+        static::assertNull($plan->root()->scan()->limit);
     }
 
     public function test_only_the_pipeline_that_reads_the_source_counts_its_rows(): void
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/PlannerTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/PlannerTest.php
index 191d1d00aa..e5feb8008f 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/PlannerTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/PlannerTest.php
@@ -90,7 +90,7 @@ public function test_the_default_rules_keep_every_sink_on_the_spine(): void
         );
 
         $steps = PipelineSteps::of($plan->root()->segments());
-        static::assertSame(4, $plan->root()->limit());
+        static::assertSame(4, $plan->root()->scan()->limit);
         static::assertSame(
             [SinkFeed::class, LimitTransformer::class, MemoryLoader::class, SelectEntriesTransformer::class],
             array_map(static fn($step) => $step::class, $steps),
@@ -141,8 +141,8 @@ public function test_a_linear_plan_is_one_pipeline_with_the_limit_pushed(): void
         static::assertSame(['id', 'total'], $plan->schema->references()->names());
 
         static::assertSame($csv, $plan->root()->segments()->extractor());
-        static::assertSame(5, $plan->root()->limit());
-        static::assertNull($logical->source()->limit());
+        static::assertSame(5, $plan->root()->scan()->limit);
+        static::assertNull($logical->source()->scan()->limit);
     }
 
     public function test_a_run_plan_over_one_sink_is_described_with_the_sinks_input_schema(): void
@@ -189,8 +189,8 @@ public function test_a_sort_splits_the_plan_into_two_pipelines(): void
         static::assertSame(['id', 'total', 'seller_id'], $plan->schema->references()->names());
 
         static::assertSame($csv, $upstream->segments()->extractor());
-        static::assertNull($upstream->limit());
-        static::assertNull($plan->root()->limit());
+        static::assertNull($upstream->scan()->limit);
+        static::assertNull($plan->root()->scan()->limit);
     }
 
     public function test_a_join_each_plan_refuses_its_schema_and_has_no_frame_edge(): void
@@ -234,7 +234,7 @@ public function test_a_planner_with_no_rules_plans_without_a_push(): void
         $plan = (new Planner())->plan($logical, NodeMother::context());
 
         static::assertSame($csv, $plan->root()->segments()->extractor());
-        static::assertNull($plan->root()->limit());
+        static::assertNull($plan->root()->scan()->limit);
     }
 
     public function test_a_join_plans_its_right_side_as_a_physical_plan_of_its_own(): void
@@ -316,7 +316,7 @@ public function test_a_read_frame_is_a_source_of_this_pipeline(): void
             PipelineSteps::classes($plan->root()->segments()),
         );
         static::assertSame($extractor, $plan->root()->segments()->extractor());
-        static::assertSame(5, $plan->root()->limit());
+        static::assertSame(5, $plan->root()->scan()->limit);
     }
 
     public function test_a_read_frame_describes_the_rows_without_reading_them(): void
@@ -412,10 +412,7 @@ public function test_a_limit_over_a_read_frame_is_pushed_into_its_extractor(): v
 
         static::assertSame(
             1,
-            (new Planner(Optimizer::default()))
-                ->plan($logical, NodeMother::context())
-                ->root()
-                ->limit(),
+            (new Planner(Optimizer::default()))->plan($logical, NodeMother::context())->root()->scan()->limit,
         );
     }
 
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Definition/StringDefinitionTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Definition/StringDefinitionTest.php
index 2fdc52f2c5..3f66734e82 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Definition/StringDefinitionTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Definition/StringDefinitionTest.php
@@ -13,9 +13,14 @@
 use PHPUnit\Framework\Attributes\DataProvider;
 
 use function Flow\ETL\DSL\bool_schema;
+use function Flow\ETL\DSL\definition_from_array;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\int_schema;
 use function Flow\ETL\DSL\null_schema;
 use function Flow\ETL\DSL\string_schema;
+use function Flow\Types\DSL\type_equals;
+use function Flow\Types\DSL\type_numeric_string;
+use function Flow\Types\DSL\type_string;
 
 final class StringDefinitionTest extends FlowTestCase
 {
@@ -67,6 +72,25 @@ public static function provideMergeCases(): Generator
         ];
     }
 
+    public function test_a_numeric_string_definition_keeps_its_type_through_every_rebuild(): void
+    {
+        $def = definition_from_type('id', type_numeric_string());
+
+        static::assertInstanceOf(StringDefinition::class, $def);
+        static::assertTrue(type_equals(type_numeric_string(), $def->type()));
+        static::assertTrue(type_equals(type_numeric_string(), $def->makeNullable()->type()));
+        static::assertTrue(type_equals(type_numeric_string(), $def->rename('other')->type()));
+        static::assertTrue(type_equals(type_numeric_string(), $def->setMetadata(Metadata::with('k', 'v'))->type()));
+        static::assertTrue(type_equals(type_numeric_string(), $def->addMetadata('k', 'v')->type()));
+        static::assertTrue(type_equals(
+            type_numeric_string(),
+            $def->merge(definition_from_type('id', type_numeric_string()))->type(),
+        ));
+        static::assertTrue(type_equals(type_numeric_string(), $def->merge(null_schema('id'))->type()));
+        static::assertTrue(type_equals(type_string(), $def->merge(string_schema('id'))->type()));
+        static::assertTrue($def->isSame(definition_from_array($def->normalize())));
+    }
+
     public function test_add_metadata(): void
     {
         $def = string_schema('name');
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Formatter/PHPSchemaFormatterTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Formatter/PHPSchemaFormatterTest.php
index 4a7d3f8ccb..9eda4c6c97 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Formatter/PHPSchemaFormatterTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Schema/Formatter/PHPSchemaFormatterTest.php
@@ -12,6 +12,7 @@
 use function Flow\ETL\DSL\bool_schema;
 use function Flow\ETL\DSL\date_schema;
 use function Flow\ETL\DSL\datetime_schema;
+use function Flow\ETL\DSL\definition_from_type;
 use function Flow\ETL\DSL\enum_schema;
 use function Flow\ETL\DSL\float_schema;
 use function Flow\ETL\DSL\html_element_schema;
@@ -31,6 +32,7 @@
 use function Flow\Types\DSL\type_integer;
 use function Flow\Types\DSL\type_list;
 use function Flow\Types\DSL\type_map;
+use function Flow\Types\DSL\type_numeric_string;
 use function Flow\Types\DSL\type_optional;
 use function Flow\Types\DSL\type_string;
 use function Flow\Types\DSL\type_structure;
@@ -88,6 +90,15 @@ public function test_formatting_map_schema(): void
         ))));
     }
 
+    public function test_formatting_numeric_string_schema(): void
+    {
+        static::assertEquals(<<<'PHP'
+            \Flow\ETL\DSL\schema(
+                \Flow\ETL\DSL\definition_from_type("id", type: \Flow\Types\DSL\type_numeric_string(), nullable: true, metadata: \Flow\ETL\DSL\schema_metadata()),
+            );
+            PHP, (new PHPSchemaFormatter())->format(schema(definition_from_type('id', type_numeric_string(), true))));
+    }
+
     public function test_formatting_simple_schema(): void
     {
         static::assertEquals(<<<PHP
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/BranchedTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/BranchedTest.php
index 7f141b5f2c..36461c5d5b 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/BranchedTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/BranchedTest.php
@@ -72,8 +72,8 @@ public function test_with_transformation_filters_before_it_transforms(): void
             │        Extractor: ArrayExtractor
             └─ #5 Write  preserving · opaque · streaming
                │  Loader: MemoryLoader
-               └─ #4 Select  preserving · transparent · streaming
-                  │  Columns: id
+               └─ #4 Select  preserving · transparent · streaming · redefines all but id
+                  │  Keeps only: id
                   └─ #3 Filter  reducing · transparent · streaming
                      │  Condition: Equals
                      └─ #1 Read (shared)
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/TransformedTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/TransformedTest.php
index f571549e51..6aa9f5aa96 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/TransformedTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Sink/TransformedTest.php
@@ -62,8 +62,8 @@ public function test_a_transformation_builds_through_the_frames_verbs(): void
             │        Extractor: ArrayExtractor
             └─ #4 Write  preserving · opaque · streaming
                │  Loader: MemoryLoader
-               └─ #3 Select  preserving · transparent · streaming
-                  │  Columns: id
+               └─ #3 Select  preserving · transparent · streaming · redefines all but id
+                  │  Keeps only: id
                   └─ #1 Read (shared)
             PLAN, $dataFrame->explain()->toString(format: Format::declarations));
     }
diff --git a/src/core/etl/tests/Flow/ETL/Tests/Unit/Transformer/ScalarFunctionFilterTransformerTest.php b/src/core/etl/tests/Flow/ETL/Tests/Unit/Transformer/ScalarFunctionFilterTransformerTest.php
index 313fda2876..68ee8e404a 100644
--- a/src/core/etl/tests/Flow/ETL/Tests/Unit/Transformer/ScalarFunctionFilterTransformerTest.php
+++ b/src/core/etl/tests/Flow/ETL/Tests/Unit/Transformer/ScalarFunctionFilterTransformerTest.php
@@ -231,4 +231,18 @@ public function test_bind_refuses_a_root_expand_over_booleans(): void
 
         (new ScalarFunctionFilterTransformer(ref('flags')->expand()))->bind(ListColumnsMother::schema());
     }
+
+    public function test_the_bound_transformer_keeps_the_rows_its_predicate_matches(): void
+    {
+        $input = schema(int_schema('a'));
+        $bound = (new ScalarFunctionFilterTransformer(ref('a')->greaterThan(lit(1))))->bind($input)->step;
+
+        static::assertInstanceOf(ScalarFunctionFilterTransformer::class, $bound);
+        static::assertSame(
+            [['a' => 2], ['a' => 3]],
+            $bound
+                ->transform(array_to_rows([['a' => 1], ['a' => 2], ['a' => 3]], $input), flow_context(config()))
+                ->toArray(),
+        );
+    }
 }
diff --git a/src/core/etl/tests/Flow/Floe/Tests/Unit/FloeExtractorTest.php b/src/core/etl/tests/Flow/Floe/Tests/Unit/FloeExtractorTest.php
index 6dc5defddd..3510f1bdda 100644
--- a/src/core/etl/tests/Flow/Floe/Tests/Unit/FloeExtractorTest.php
+++ b/src/core/etl/tests/Flow/Floe/Tests/Unit/FloeExtractorTest.php
@@ -6,6 +6,7 @@
 
 use Flow\ETL\Exception\InferredSchemaException;
 use Flow\ETL\Exception\InvalidArgumentException;
+use Flow\ETL\Extractor\File\FileScan;
 use Flow\ETL\Extractor\Signal;
 use Flow\ETL\Tests\Double\CountingFilesystem;
 use Flow\ETL\Tests\Double\SpyBackend;
@@ -489,7 +490,10 @@ public function test_a_path_filter_narrows_the_read_but_not_the_schema(): void
         $extractor = from_floe(path('memory://parts/*/*.floe'), filesystem: $counting);
         $schema = $extractor->schema();
 
-        $batches = iterator_to_array($extractor->extract(flow_context(config()), pathFilter: new RejectingFilter()));
+        $batches = iterator_to_array($extractor->scan(
+            flow_context(config()),
+            new FileScan(pathFilter: new RejectingFilter()),
+        ));
 
         static::assertSame([], $batches);
         static::assertSame(1, $counting->readFromCalls);
diff --git a/src/extension/arrow-ext/Cargo.lock b/src/extension/arrow-ext/Cargo.lock
index d69bb02fa8..1e7d3c2577 100644
--- a/src/extension/arrow-ext/Cargo.lock
+++ b/src/extension/arrow-ext/Cargo.lock
@@ -44,15 +44,15 @@ dependencies = [
 
 [[package]]
 name = "alloc-no-stdlib"
-version = "2.0.4"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+checksum = "c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a"
 
 [[package]]
 name = "alloc-stdlib"
-version = "0.2.2"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+checksum = "0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1"
 dependencies = [
  "alloc-no-stdlib",
 ]
@@ -87,9 +87,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-array"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e5f6adeffdf587d7a31db5d2266189624b526730cd3627f9ff9fedae97ad584"
+checksum = "51dff6e4b9f158864a0aeb6a131ad53858ecbae7a2fc8989307b9b3c6b2f122e"
 dependencies = [
  "ahash",
  "arrow-buffer",
@@ -106,9 +106,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-buffer"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "097d193003ce7995d5d087089069ec2a6e0187faf5a6f8c9f38af2645d987182"
+checksum = "c7235b863533e9db3ab86905b4521251de11226275b436ff3cb2d0010558d1c5"
 dependencies = [
  "bytes",
  "half",
@@ -116,11 +116,22 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "arrow-cmp"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73a0e9adb28d95739fabcdae637261a2c14e618caf58ba1b88857120f9ee2687"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-schema",
+]
+
 [[package]]
 name = "arrow-data"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ba2f832eaeca24b8f26143dba750e42ee4ab51cf7d65e701ca9607cfda9f358"
+checksum = "5aa06d5e22786c4966ffc4d2f171d0cb65d95f6bdea108a14e8c335e9faa437f"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
@@ -131,9 +142,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-ipc"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcc41681ea80f521df14c36725b74d4c60702c47f0793af2be469c04527e2599"
+checksum = "86c523472d22e31f984df7a44fc36e6323d3c9b05ffe53d267ee4c3aa7c128d2"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -145,9 +156,9 @@ dependencies = [
 
 [[package]]
 name = "arrow-schema"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10fab8d4563491417ba801fab29d205104d20d4bdf37bda6cd1cf425cff598cd"
+checksum = "f85a9a58cd03560526b0066487574aacb9008e413504fa0ee23d61141e96c338"
 dependencies = [
  "bitflags",
  "serde_core",
@@ -156,13 +167,14 @@ dependencies = [
 
 [[package]]
 name = "arrow-select"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc58569193c2525915f3cc6310edba3792f1200f65d6e9ed330aa33e691493b8"
+checksum = "ba3482b7d03bf4a3bf0b195f08a7f2b071595ccd54897e35b975ac63d3104977"
 dependencies = [
  "ahash",
  "arrow-array",
  "arrow-buffer",
+ "arrow-cmp",
  "arrow-data",
  "arrow-schema",
  "num-traits",
@@ -207,7 +219,7 @@ dependencies = [
  "regex",
  "rustc-hash",
  "shlex 2.0.1",
- "syn 2.0.117",
+ "syn 3.0.6",
 ]
 
 [[package]]
@@ -227,9 +239,9 @@ dependencies = [
 
 [[package]]
 name = "brotli"
-version = "8.0.2"
+version = "9.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+checksum = "f8b851b75c23ca7873623d612fe49bd1989aeb03d08fb9432187eb253d3d4c6b"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -238,9 +250,9 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "5.0.0"
+version = "6.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+checksum = "941cd9bd4ddab83cb46fa5a2d428f1c857b24ac78cb876cf7beb710840934bd7"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -1115,9 +1127,9 @@ dependencies = [
 
 [[package]]
 name = "parquet"
-version = "59.3.0"
+version = "60.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff322f54b1a0f9288e614ed1f2d329b380af5476420db19f46ffb865e1163d73"
+checksum = "8af83d2940bc0510f9aef86d865f56fdc6095f87ab115ac885a80b7c5226d3ba"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -1141,7 +1153,7 @@ dependencies = [
  "simdutf8",
  "snap",
  "twox-hash",
- "zstd",
+ "zstd 0.14.2",
 ]
 
 [[package]]
@@ -2021,7 +2033,7 @@ dependencies = [
  "typed-path",
  "zeroize",
  "zopfli",
- "zstd",
+ "zstd 0.13.3",
 ]
 
 [[package]]
@@ -2054,7 +2066,16 @@ version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
 dependencies = [
- "zstd-safe",
+ "zstd-safe 7.2.4",
+]
+
+[[package]]
+name = "zstd"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "057cfd910cfac363a0ada849592624b4c9ff2e10bef504c3433810d78ed96f93"
+dependencies = [
+ "zstd-safe 8.1.0",
 ]
 
 [[package]]
@@ -2066,11 +2087,20 @@ dependencies = [
  "zstd-sys",
 ]
 
+[[package]]
+name = "zstd-safe"
+version = "8.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdd44c6a7284e91f3717755b24315a302edd9153a01f753c3cba3d765e8eafac"
+dependencies = [
+ "zstd-sys",
+]
+
 [[package]]
 name = "zstd-sys"
-version = "2.0.16+zstd.1.5.7"
+version = "2.1.1+zstd.1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+checksum = "aeec9eaf2dffbbd09201e23bd0ffcbaa33bb8e9266a10734fd7ed90a85eca078"
 dependencies = [
  "cc",
  "pkg-config",
diff --git a/src/extension/arrow-ext/Cargo.toml b/src/extension/arrow-ext/Cargo.toml
index e528e0f770..0bbb474083 100644
--- a/src/extension/arrow-ext/Cargo.toml
+++ b/src/extension/arrow-ext/Cargo.toml
@@ -8,10 +8,10 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ext-php-rs = "0.16"
-parquet = { version = "59", default-features = false, features = ["arrow", "arrow_canonical_extension_types", "snap", "flate2", "flate2-zlib-rs", "zstd", "lz4", "brotli", "simdutf8"] }
-arrow-array = { version = "59", features = ["ffi"] }
-arrow-buffer = "59"
-arrow-schema = { version = "59", features = ["canonical_extension_types"] }
+parquet = { version = "60", default-features = false, features = ["arrow", "arrow_canonical_extension_types", "snap", "flate2", "flate2-zlib-rs", "zstd", "lz4", "brotli", "simdutf8"] }
+arrow-array = { version = "60", features = ["ffi"] }
+arrow-buffer = "60"
+arrow-schema = { version = "60", features = ["canonical_extension_types"] }
 bytes = "1"
 
 [build-dependencies]
diff --git a/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustBatchReader.php b/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustBatchReader.php
index 6ea532f5c8..473d266161 100644
--- a/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustBatchReader.php
+++ b/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustBatchReader.php
@@ -7,6 +7,7 @@
 use Flow\Arrow\RustArrowSchema;
 use Flow\Arrow\RustParquetBatch;
 use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
 use RuntimeException;
 
 use function extension_loaded;
@@ -21,7 +22,7 @@ final class RustBatchReader
      * @param list<string> $columns root column names
      * @param int<1, max> $batchSize
      */
-    public function __construct(RustParquetFileReader $file, array $columns, int $batchSize, ?int $offset, ?int $limit)
+    public function __construct(RustParquetFileReader $file, array $columns, int $batchSize, ReadPlan $plan)
     {
         throw new RuntimeException('arrow extension is not loaded');
     }
diff --git a/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustColumnsReader.php b/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustColumnsReader.php
index bf7ee0a131..c39b3400d5 100644
--- a/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustColumnsReader.php
+++ b/src/extension/arrow-ext/php/Flow/Arrow/Parquet/RustColumnsReader.php
@@ -5,6 +5,7 @@
 namespace Flow\Arrow\Parquet;
 
 use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
 use Iterator;
 use RuntimeException;
 
@@ -25,7 +26,7 @@ final class RustColumnsReader implements Iterator
      * @param list<string> $columns root names or struct paths
      * @param int<1, max> $batchSize
      */
-    public function __construct(RustParquetFileReader $file, array $columns, int $batchSize, ?int $offset, ?int $limit)
+    public function __construct(RustParquetFileReader $file, array $columns, int $batchSize, ReadPlan $plan)
     {
         throw new RuntimeException('arrow extension is not loaded');
     }
diff --git a/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFileReader.php b/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFileReader.php
index 7e041d8abc..38e400fded 100644
--- a/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFileReader.php
+++ b/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFileReader.php
@@ -6,10 +6,8 @@
 
 use Flow\Arrow\Parquet\RustColumnsReader;
 use Flow\Filesystem\SourceStream;
-use Flow\Parquet\ParquetFile\Metadata;
-use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFileReader;
-use Flow\Parquet\ThriftModel\FileMetaData;
+use Flow\Parquet\Reader\ReadPlan;
 use RuntimeException;
 
 use function extension_loaded;
@@ -30,49 +28,27 @@ public function __construct(SourceStream $stream, bool $int96AsDatetime = true)
     }
 
     /**
-     * Closes the stream; any later call throws \Flow\Parquet\Exception\RuntimeException('Reader is not open').
+     * Closes the stream; any later call throws \Flow\Parquet\Exception\RuntimeException('Reader is not open'). A
+     * footer taken before stays readable.
      */
     public function close(): void
     {
         throw new RuntimeException('arrow extension is not loaded');
     }
 
-    public function metadata(): Metadata
-    {
-        throw new RuntimeException('arrow extension is not loaded');
-    }
-
-    /**
-     * @param list<string> $columns resolved names, never empty
-     * @param int<1, max> $batchSize upper bound of rows per chunk
-     */
-    public function readColumns(array $columns, int $batchSize, ?int $limit, ?int $offset): RustColumnsReader
-    {
-        throw new RuntimeException('arrow extension is not loaded');
-    }
-
-    public function rowsNumber(): int
-    {
-        throw new RuntimeException('arrow extension is not loaded');
-    }
-
-    public function schema(): Schema
-    {
-        throw new RuntimeException('arrow extension is not loaded');
-    }
-
     /**
-     * The whole footer, decoded on the first call.
+     * Created on the first call.
      */
-    public function thrift(): FileMetaData
+    public function footer(): RustParquetFooter
     {
         throw new RuntimeException('arrow extension is not loaded');
     }
 
     /**
-     * Σ row group total_byte_size (uncompressed).
+     * @param list<string> $columns resolved names, never empty
+     * @param int $batchSize upper bound of rows per chunk, refused below 1
      */
-    public function totalByteSize(): int
+    public function readColumns(array $columns, int $batchSize, ReadPlan $plan): RustColumnsReader
     {
         throw new RuntimeException('arrow extension is not loaded');
     }
diff --git a/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFooter.php b/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFooter.php
new file mode 100644
index 0000000000..6eaf75423a
--- /dev/null
+++ b/src/extension/arrow-ext/php/Flow/Parquet/Engine/RustParquetFooter.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Engine;
+
+use Flow\Parquet\ParquetFile\Footer;
+use Flow\Parquet\ParquetFile\Metadata;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ThriftModel\FileMetaData;
+use RuntimeException;
+
+use function extension_loaded;
+
+if (extension_loaded('arrow')) {
+    return;
+}
+
+/**
+ * Created by RustParquetFileReader::footer() only.
+ */
+final class RustParquetFooter implements Footer
+{
+    public function metadata(): Metadata
+    {
+        throw new RuntimeException('arrow extension is not loaded');
+    }
+
+    /**
+     * A RustRowGroupChunks: the requested leaves' column chunks of every row group, sliced from the footer and
+     * decoded on first access.
+     *
+     * @param list<FlatColumn> $columns
+     */
+    public function rowGroupChunks(array $columns): RowGroupChunks
+    {
+        throw new RuntimeException('arrow extension is not loaded');
+    }
+
+    public function rowsNumber(): int
+    {
+        throw new RuntimeException('arrow extension is not loaded');
+    }
+
+    public function schema(): Schema
+    {
+        throw new RuntimeException('arrow extension is not loaded');
+    }
+
+    /**
+     * The whole footer, decoded on the first call.
+     */
+    public function thrift(): FileMetaData
+    {
+        throw new RuntimeException('arrow extension is not loaded');
+    }
+
+    /**
+     * Σ row group total_byte_size (uncompressed).
+     */
+    public function totalByteSize(): int
+    {
+        throw new RuntimeException('arrow extension is not loaded');
+    }
+}
diff --git a/src/extension/arrow-ext/src/interfaces.rs b/src/extension/arrow-ext/src/interfaces.rs
index cc8589a753..316de354b9 100644
--- a/src/extension/arrow-ext/src/interfaces.rs
+++ b/src/extension/arrow-ext/src/interfaces.rs
@@ -1,4 +1,4 @@
-//! `Flow\Parquet\{ParquetEngine, ParquetFileReader, ParquetFileWriter}`: registered at MINIT with the package files'
+//! `Flow\Parquet\{ParquetEngine, ParquetFileReader, ParquetFileWriter}` and `Flow\Parquet\ParquetFile\Footer`: registered at MINIT with the package files'
 //! exact signatures, so the extension's classes implement them and the package files (autoloaded only without arrow)
 //! stay unused.
 
@@ -14,14 +14,18 @@ const SOURCE_STREAM: DataType = DataType::object("Flow\\Filesystem\\SourceStream
 const DESTINATION_STREAM: DataType = DataType::object("Flow\\Filesystem\\DestinationStream");
 const SCHEMA: DataType = DataType::object("Flow\\Parquet\\ParquetFile\\Schema");
 const METADATA: DataType = DataType::object("Flow\\Parquet\\ParquetFile\\Metadata");
+const READ_PLAN: DataType = DataType::object("Flow\\Parquet\\Reader\\ReadPlan");
+const ROW_GROUP_CHUNKS: DataType = DataType::object("Flow\\Parquet\\ParquetFile\\RowGroupChunks");
 const COMPRESSIONS: DataType = DataType::object("Flow\\Parquet\\ParquetFile\\Compressions");
 const OPTIONS: DataType = DataType::object("Flow\\Parquet\\Options");
+const FOOTER: DataType = DataType::object("Flow\\Parquet\\ParquetFile\\Footer");
 const PARQUET_FILE_READER: DataType = DataType::object("Flow\\Parquet\\ParquetFileReader");
 const PARQUET_FILE_WRITER: DataType = DataType::object("Flow\\Parquet\\ParquetFileWriter");
 const ITERATOR: DataType = DataType::object("Iterator");
 
 // ClassEntry::try_find reads EG(class_table), which MINIT has not set, so each CE is kept from its registration
 static PARQUET_ENGINE_CE: AtomicPtr<ClassEntry> = AtomicPtr::new(std::ptr::null_mut());
+static FOOTER_CE: AtomicPtr<ClassEntry> = AtomicPtr::new(std::ptr::null_mut());
 static PARQUET_FILE_READER_CE: AtomicPtr<ClassEntry> = AtomicPtr::new(std::ptr::null_mut());
 static PARQUET_FILE_WRITER_CE: AtomicPtr<ClassEntry> = AtomicPtr::new(std::ptr::null_mut());
 
@@ -30,6 +34,11 @@ fn store_parquet_engine(ce: &'static mut ClassEntry, arg_info: ArgInfoTables) {
     PARQUET_ENGINE_CE.store(ce, Ordering::Release);
 }
 
+fn store_footer(ce: &'static mut ClassEntry, arg_info: ArgInfoTables) {
+    keep(arg_info);
+    FOOTER_CE.store(ce, Ordering::Release);
+}
+
 fn store_parquet_file_reader(ce: &'static mut ClassEntry, arg_info: ArgInfoTables) {
     keep(arg_info);
     PARQUET_FILE_READER_CE.store(ce, Ordering::Release);
@@ -53,6 +62,10 @@ pub fn parquet_engine_ce() -> &'static ClassEntry {
     load(&PARQUET_ENGINE_CE, "Flow\\Parquet\\ParquetEngine")
 }
 
+pub fn footer_ce() -> &'static ClassEntry {
+    load(&FOOTER_CE, "Flow\\Parquet\\ParquetFile\\Footer")
+}
+
 pub fn parquet_file_reader_ce() -> &'static ClassEntry {
     load(&PARQUET_FILE_READER_CE, "Flow\\Parquet\\ParquetFileReader")
 }
@@ -82,25 +95,36 @@ fn interface(
 }
 
 pub fn register() -> Result<()> {
+    interface(
+        "Flow\\Parquet\\ParquetFile\\Footer",
+        store_footer,
+        vec![
+            method("metadata", vec![], METADATA),
+            method(
+                "rowGroupChunks",
+                vec![Arg::new("columns", DataType::Array)],
+                ROW_GROUP_CHUNKS,
+            ),
+            method("rowsNumber", vec![], DataType::Long),
+            method("schema", vec![], SCHEMA),
+            method("totalByteSize", vec![], DataType::Long),
+        ],
+    )?;
     interface(
         "Flow\\Parquet\\ParquetFileReader",
         store_parquet_file_reader,
         vec![
             method("close", vec![], DataType::Void),
-            method("metadata", vec![], METADATA),
+            method("footer", vec![], FOOTER),
             method(
                 "readColumns",
                 vec![
                     Arg::new("columns", DataType::Array),
                     Arg::new("batchSize", DataType::Long),
-                    Arg::new("limit", DataType::Long).allow_null(),
-                    Arg::new("offset", DataType::Long).allow_null(),
+                    Arg::new("plan", READ_PLAN),
                 ],
                 ITERATOR,
             ),
-            method("rowsNumber", vec![], DataType::Long),
-            method("schema", vec![], SCHEMA),
-            method("totalByteSize", vec![], DataType::Long),
         ],
     )?;
     interface(
diff --git a/src/extension/arrow-ext/src/lib.rs b/src/extension/arrow-ext/src/lib.rs
index 8804b3bff3..5d194b8aa6 100644
--- a/src/extension/arrow-ext/src/lib.rs
+++ b/src/extension/arrow-ext/src/lib.rs
@@ -29,8 +29,8 @@ pub extern "C" fn php_module_info(_module: *mut ModuleEntry) {
 }
 
 /// The contract version flow-php/parquet expects (`Flow\Parquet\Engine\ArrowExtension::ABI`); both change together
-/// whenever a registered class or interface changes.
-const FLOW_ARROW_ABI: i64 = 1;
+/// whenever a registered class or interface, or the schema, options or values crossing them, change.
+const FLOW_ARROW_ABI: i64 = 2;
 
 /// # Safety
 ///
@@ -55,6 +55,7 @@ pub fn get_module(module: ModuleBuilder) -> ModuleBuilder {
         .request_startup_function(php::request_startup)
         .request_shutdown_function(php::request_shutdown)
         .class::<parquet::library::RustColumnsReader>()
+        .class::<parquet::library::RustParquetFooter>()
         .class::<parquet::library::RustParquetFileReader>()
         .class::<parquet::library::RustParquetFileWriter>()
         .class::<parquet::engine::RustParquetEngine>()
diff --git a/src/extension/arrow-ext/src/parquet/batch.rs b/src/extension/arrow-ext/src/parquet/batch.rs
index 60d5fde10f..af91b7ccdc 100644
--- a/src/extension/arrow-ext/src/parquet/batch.rs
+++ b/src/extension/arrow-ext/src/parquet/batch.rs
@@ -15,8 +15,8 @@ use ext_php_rs::types::{ZendObject, Zval};
 use ext_php_rs::zend::ClassEntry;
 
 use crate::parquet::error::Error;
-use crate::parquet::library::{batch_size, rows, RustParquetFileReader, INVALID_ARGUMENT};
-use crate::parquet::read::{ParquetReader, ReadPlan};
+use crate::parquet::library::{batch_size, read_plan, RustParquetFileReader, INVALID_ARGUMENT};
+use crate::parquet::read::ParquetReader;
 use crate::parquet::source::PhpStream;
 use crate::php::{call_handle_transparent, ce_method_ref};
 use crate::render::{exception, parquet_exception, Side};
@@ -83,22 +83,14 @@ impl RustBatchReader {
         file: &RustParquetFileReader,
         columns: Vec<String>,
         batch_size: i64,
-        offset: Option<i64>,
-        limit: Option<i64>,
+        plan: &Zval,
     ) -> PhpResult<Self> {
         let batch_size = self::batch_size(batch_size)?;
-        let (offset, limit) = (rows(offset, "offset")?.unwrap_or(0), rows(limit, "limit")?);
-        let (stream, size, meta) = file.read()?;
+        let (stream, meta) = file.read()?;
         let stream = Arc::clone(stream);
-        let reader = ParquetReader::open(
-            Arc::clone(&stream),
-            size,
-            meta,
-            &columns,
-            ReadPlan::new(meta, offset, limit),
-            batch_size,
-        )
-        .map_err(|error| parquet_exception(error, &stream, Side::Read))?;
+        let plan = read_plan(meta, plan, &stream)?;
+        let reader = ParquetReader::open(Arc::clone(&stream), meta, &columns, plan, batch_size)
+            .map_err(|error| parquet_exception(error, &stream, Side::Read))?;
         let fields = columns
             .iter()
             .zip(reader.fields())
@@ -188,26 +180,13 @@ pub fn import(batch: &Zval) -> PhpResult<StructArray> {
         )));
     }
 
-    let schema = unsafe { &*(address(object, ce, "arrowSchemaAddress")? as *const FFI_ArrowSchema) };
-    let source = unsafe { &mut *(address(object, ce, "arrowArrayAddress")? as *mut FFI_ArrowArray) };
-
-    if schema.format.is_null() || unsafe { CStr::from_ptr(schema.format) }.to_bytes() != b"+s" {
-        return Err(refused("Arrow C Data batch must be a struct array".to_string()));
-    }
-
-    if source.release.is_none() {
-        return Err(refused("Arrow C Data batch is already imported".to_string()));
-    }
+    let schema = address(object, ce, "arrowSchemaAddress")? as *const FFI_ArrowSchema;
+    let source = address(object, ce, "arrowArrayAddress")? as *mut FFI_ArrowArray;
 
-    if source.n_children != schema.n_children || source.length < 0 {
-        return Err(refused(format!(
-            "Arrow C Data batch of {} children does not match its schema of {}",
-            source.n_children, schema.n_children
-        )));
-    }
+    unsafe { check(schema, source) }.map_err(refused)?;
 
-    let moved = unsafe { std::ptr::read(source) };
-    source.release = None;
+    let schema = unsafe { &*schema };
+    let moved = unsafe { FFI_ArrowArray::from_raw(source) };
 
     let data = unsafe { from_ffi(moved, schema) }
         .and_then(|data| data.validate().map(|()| data))
@@ -216,6 +195,59 @@ pub fn import(batch: &Zval) -> PhpResult<StructArray> {
     Ok(StructArray::from(data))
 }
 
+/// The leading fields of `struct ArrowSchema` and `struct ArrowArray` as the Arrow C Data Interface specification
+/// declares them (https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions): read before the
+/// arrow-rs accessors, which panic on a null format and cast a negative count to `usize`.
+#[repr(C)]
+struct SchemaHead {
+    format: *const c_char,
+    name: *const c_char,
+    metadata: *const c_char,
+    flags: i64,
+    n_children: i64,
+}
+
+#[repr(C)]
+struct ArrayHead {
+    length: i64,
+    null_count: i64,
+    offset: i64,
+    n_buffers: i64,
+    n_children: i64,
+}
+
+/// # Safety
+///
+/// `schema` and `array` point to live C Data Interface structs.
+unsafe fn check(schema: *const FFI_ArrowSchema, array: *const FFI_ArrowArray) -> Result<(), String> {
+    let schema_head = unsafe { &*(schema as *const SchemaHead) };
+    let array_head = unsafe { &*(array as *const ArrayHead) };
+
+    if schema_head.format.is_null() || unsafe { CStr::from_ptr(schema_head.format) }.to_bytes() != b"+s" {
+        return Err("Arrow C Data batch must be a struct array".to_string());
+    }
+
+    if unsafe { &*array }.is_released() {
+        return Err("Arrow C Data batch is already imported".to_string());
+    }
+
+    if array_head.length < 0 {
+        return Err(format!(
+            "Arrow C Data batch length must not be negative, {} given",
+            array_head.length
+        ));
+    }
+
+    if array_head.n_children < 0 || schema_head.n_children < 0 || array_head.n_children != schema_head.n_children {
+        return Err(format!(
+            "Arrow C Data batch of {} children does not match its schema of {}",
+            array_head.n_children, schema_head.n_children
+        ));
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -271,4 +303,53 @@ mod tests {
 
         assert_eq!(allocated_bytes(), baseline);
     }
+
+    fn refusal(mutate: impl FnOnce(*mut super::SchemaHead, *mut super::ArrayHead)) -> Result<(), String> {
+        let (mut array, mut schema) = to_ffi(&batch().to_data()).unwrap();
+        let schema_ptr = &mut schema as *mut arrow_array::ffi::FFI_ArrowSchema;
+        let array_ptr = &mut array as *mut arrow_array::ffi::FFI_ArrowArray;
+        let schema_head = schema_ptr as *mut super::SchemaHead;
+        let array_head = array_ptr as *mut super::ArrayHead;
+        let (format, length, children) =
+            unsafe { ((*schema_head).format, (*array_head).length, (*array_head).n_children) };
+
+        mutate(schema_head, array_head);
+        let result = unsafe { super::check(schema_ptr, array_ptr) };
+
+        unsafe {
+            (*schema_head).format = format;
+            (*array_head).length = length;
+            (*array_head).n_children = children;
+        }
+
+        result
+    }
+
+    #[test]
+    fn a_null_format_is_refused_before_the_accessors() {
+        assert_eq!(
+            refusal(|schema, _| unsafe { (*schema).format = std::ptr::null() }),
+            Err("Arrow C Data batch must be a struct array".to_string())
+        );
+    }
+
+    #[test]
+    fn a_negative_length_is_refused() {
+        assert_eq!(
+            refusal(|_, array| unsafe { (*array).length = -1 }),
+            Err("Arrow C Data batch length must not be negative, -1 given".to_string())
+        );
+    }
+
+    #[test]
+    fn a_negative_or_mismatched_child_count_is_refused() {
+        assert_eq!(
+            refusal(|_, array| unsafe { (*array).n_children = -1 }),
+            Err("Arrow C Data batch of -1 children does not match its schema of 2".to_string())
+        );
+        assert_eq!(
+            refusal(|_, array| unsafe { (*array).n_children = 1 }),
+            Err("Arrow C Data batch of 1 children does not match its schema of 2".to_string())
+        );
+    }
 }
diff --git a/src/extension/arrow-ext/src/parquet/canonical.rs b/src/extension/arrow-ext/src/parquet/canonical.rs
index 80b5dfaca2..fc19dbae2a 100644
--- a/src/extension/arrow-ext/src/parquet/canonical.rs
+++ b/src/extension/arrow-ext/src/parquet/canonical.rs
@@ -2,8 +2,10 @@
 //! storage (the layout flow_php's columns store), keyed on the arrow `DataType` alone. Temporal and decimal
 //! casts are this module's own - `arrow_cast` rounds toward zero and nulls out overflows.
 
+use std::fmt::Write;
 use std::sync::Arc;
 
+use arrow_array::builder::LargeBinaryBuilder;
 use arrow_array::cast::AsArray;
 use arrow_array::types::{
     Date32Type, Date64Type, Decimal128Type, Decimal256Type, DecimalType, DurationMicrosecondType, Float32Type,
@@ -13,11 +15,12 @@ use arrow_array::types::{
 };
 use arrow_array::{
     make_array, Array, ArrayRef, ArrowPrimitiveType, BinaryArray, FixedSizeBinaryArray, Float64Array, GenericByteArray,
-    LargeBinaryArray, ListArray, MapArray, PrimitiveArray, StructArray,
+    LargeBinaryArray, ListArray, MapArray, PrimitiveArray, StructArray, UInt64Array,
 };
 use arrow_buffer::{OffsetBuffer, ScalarBuffer};
 use arrow_schema::{DataType, Field, FieldRef, Fields, TimeUnit};
 
+use crate::parquet::cells::{unsigned, UNSIGNED_EXPECTED};
 use crate::parquet::error::{parent_row, Error};
 
 const UTC: &str = "UTC";
@@ -62,19 +65,16 @@ fn canonical_data_type(data_type: &DataType) -> Result<DataType, Error> {
         | DataType::Float64
         | DataType::Date32
         | DataType::FixedSizeBinary(16) => data_type.clone(),
-        DataType::Int8
-        | DataType::Int16
-        | DataType::Int32
-        | DataType::UInt8
-        | DataType::UInt16
-        | DataType::UInt32
-        | DataType::UInt64 => DataType::Int64,
+        DataType::Int8 | DataType::Int16 | DataType::Int32 | DataType::UInt8 | DataType::UInt16 | DataType::UInt32 => {
+            DataType::Int64
+        }
         DataType::Float32 | DataType::Decimal128(_, _) | DataType::Decimal256(_, _) => DataType::Float64,
         DataType::Utf8
         | DataType::Binary
         | DataType::LargeUtf8
         | DataType::LargeBinary
-        | DataType::FixedSizeBinary(_) => DataType::LargeBinary,
+        | DataType::FixedSizeBinary(_)
+        | DataType::UInt64 => DataType::LargeBinary,
         DataType::Timestamp(_, _) => timestamp(),
         DataType::Time64(TimeUnit::Microsecond | TimeUnit::Nanosecond)
         | DataType::Time32(TimeUnit::Millisecond | TimeUnit::Second) => DataType::Duration(TimeUnit::Microsecond),
@@ -146,6 +146,47 @@ fn checked<T: ArrowPrimitiveType, O: ArrowPrimitiveType>(
     Ok(PrimitiveArray::new(ScalarBuffer::from(values), input.nulls().cloned()))
 }
 
+/// UINT_64 from its decimal text (a `numeric_string` column): a canonical digit string up to u64::MAX, refused at its
+/// row otherwise.
+fn unsigned_from_text(array: &ArrayRef) -> Result<UInt64Array, Error> {
+    let input = array.as_binary::<i64>();
+    let mut values = Vec::with_capacity(input.len());
+
+    for row in 0..input.len() {
+        values.push(if input.is_null(row) {
+            0
+        } else {
+            unsigned(input.value(row)).ok_or_else(|| Error::Value {
+                column: String::new(),
+                row,
+                expected: UNSIGNED_EXPECTED,
+                got: "string".to_string(),
+            })?
+        });
+    }
+
+    Ok(UInt64Array::new(ScalarBuffer::from(values), input.nulls().cloned()))
+}
+
+/// UINT_64 as its decimal text: one PHP type for the column, lossless above `PHP_INT_MAX`.
+fn decimal_text(array: &ArrayRef) -> ArrayRef {
+    let input = array.as_primitive::<UInt64Type>();
+    let mut builder = LargeBinaryBuilder::with_capacity(input.len(), input.len() * 20);
+    let mut text = String::with_capacity(20);
+
+    for (row, value) in input.values().iter().enumerate() {
+        if input.is_null(row) {
+            builder.append_null();
+        } else {
+            text.clear();
+            write!(text, "{value}").expect("writing to a String does not fail");
+            builder.append_value(&text);
+        }
+    }
+
+    Arc::new(builder.finish())
+}
+
 fn retagged(array: &ArrayRef, to: DataType) -> ArrayRef {
     make_array(unsafe { array.to_data().into_builder().data_type(to).build_unchecked() })
 }
@@ -252,9 +293,7 @@ fn cast(array: &ArrayRef) -> Result<ArrayRef, Error> {
         DataType::UInt8 => widened::<UInt8Type>(array),
         DataType::UInt16 => widened::<UInt16Type>(array),
         DataType::UInt32 => widened::<UInt32Type>(array),
-        DataType::UInt64 => Arc::new(checked::<UInt64Type, Int64Type>(array, |value| {
-            i64::try_from(value).ok()
-        })?),
+        DataType::UInt64 => decimal_text(array),
         DataType::Float32 => Arc::new(array.as_primitive::<Float32Type>().unary::<_, Float64Type>(f64::from)),
         DataType::Utf8 | DataType::Binary => widened_binary(array),
         DataType::LargeUtf8 | DataType::LargeBinary => retagged(array, DataType::LargeBinary),
@@ -369,6 +408,7 @@ pub fn to_parquet(array: &ArrayRef, target: &DataType) -> Result<ArrayRef, Error
         (DataType::Int64, DataType::UInt16) => Arc::new(narrowed_int::<UInt16Type>(array)?),
         (DataType::Int64, DataType::UInt32) => Arc::new(narrowed_int::<UInt32Type>(array)?),
         (DataType::Int64, DataType::UInt64) => Arc::new(narrowed_int::<UInt64Type>(array)?),
+        (DataType::LargeBinary, DataType::UInt64) => Arc::new(unsigned_from_text(array)?),
         (DataType::Float64, DataType::Float32) => Arc::new(
             array
                 .as_primitive::<Float64Type>()
@@ -701,28 +741,39 @@ mod tests {
             int64(&read(Arc::new(UInt32Array::from(vec![Some(u32::MAX), None])))),
             vec![Some(i64::from(u32::MAX)), None]
         );
-        assert_eq!(
-            int64(&read(Arc::new(UInt64Array::from(vec![Some(i64::MAX as u64), None])))),
-            vec![Some(i64::MAX), None]
-        );
     }
 
     #[test]
-    fn uint64_above_int64_is_refused_at_its_row() {
-        let error = refusal(Arc::new(UInt64Array::from(vec![
-            Some(1),
+    fn uint64_reads_as_its_decimal_text() {
+        let canonical = read(Arc::new(UInt64Array::from(vec![
+            Some(0),
             None,
-            Some(i64::MAX as u64 + 1),
+            Some(1 << 63),
+            Some(u64::MAX),
         ])));
 
-        assert!(matches!(error, Error::Overflow { column, row: 2 } if column == "column"));
+        assert_eq!(
+            canonical.as_binary::<i64>().iter().collect::<Vec<_>>(),
+            vec![
+                Some(&b"0"[..]),
+                None,
+                Some(&b"9223372036854775808"[..]),
+                Some(&b"18446744073709551615"[..]),
+            ]
+        );
     }
 
     #[test]
     fn a_null_slot_never_overflows() {
-        let values = UInt64Array::new(vec![1, u64::MAX].into(), Some(vec![true, false].into()));
+        let values = TimestampMillisecondArray::new(vec![1, i64::MAX].into(), Some(vec![true, false].into()));
 
-        assert_eq!(int64(&read(Arc::new(values))), vec![Some(1), None]);
+        assert_eq!(
+            read(Arc::new(values))
+                .as_primitive::<TimestampMicrosecondType>()
+                .iter()
+                .collect::<Vec<_>>(),
+            vec![Some(1_000), None]
+        );
     }
 
     #[test]
@@ -952,9 +1003,13 @@ mod tests {
 
     #[test]
     fn a_nested_overflow_is_refused_at_its_parent_row() {
-        let values = Arc::new(UInt64Array::from(vec![1, 2, u64::MAX]));
+        let values = Arc::new(TimestampMillisecondArray::from(vec![1, 2, i64::MAX]));
         let list = ListArray::new(
-            Arc::new(Field::new("element", DataType::UInt64, false)),
+            Arc::new(Field::new(
+                "element",
+                DataType::Timestamp(TimeUnit::Millisecond, None),
+                false,
+            )),
             arrow_buffer::OffsetBuffer::new(vec![0, 2, 3].into()),
             values,
             None,
@@ -1025,15 +1080,16 @@ mod tests {
             vec![Some(-128), None, Some(127)]
         );
 
-        let unsigned: ArrayRef = Arc::new(Int64Array::from(vec![Some(4_000_000_000), Some(i64::MAX)]));
-
         assert_eq!(
-            to_parquet(&unsigned, &DataType::UInt64)
-                .unwrap()
-                .as_primitive::<UInt64Type>()
-                .values()
-                .to_vec(),
-            vec![4_000_000_000, i64::MAX as u64]
+            to_parquet(
+                &(Arc::new(Int64Array::from(vec![Some(4_000_000_000), None])) as ArrayRef),
+                &DataType::UInt64
+            )
+            .unwrap()
+            .as_primitive::<UInt64Type>()
+            .iter()
+            .collect::<Vec<_>>(),
+            vec![Some(4_000_000_000), None]
         );
 
         for target in [
@@ -1381,4 +1437,35 @@ mod tests {
             Err(Error::Unsupported { parquet, .. }) if parquet == "Float32"
         ));
     }
+
+    #[test]
+    fn to_parquet_reads_uint64_from_digit_text() {
+        let text: ArrayRef = Arc::new(LargeBinaryArray::from(vec![
+            Some(&b"18446744073709551615"[..]),
+            None,
+            Some(&b"0"[..]),
+        ]));
+
+        assert_eq!(
+            to_parquet(&text, &DataType::UInt64)
+                .unwrap()
+                .as_primitive::<UInt64Type>()
+                .iter()
+                .collect::<Vec<_>>(),
+            vec![Some(u64::MAX), None, Some(0)]
+        );
+    }
+
+    #[test]
+    fn to_parquet_refuses_uint64_text_that_is_not_a_canonical_digit_string() {
+        for text in [&b"18446744073709551616"[..], b"007", b"-1", b"abc", b""] {
+            let array: ArrayRef = Arc::new(LargeBinaryArray::from(vec![Some(&b"1"[..]), Some(text)]));
+
+            assert!(
+                matches!(to_parquet(&array, &DataType::UInt64), Err(Error::Value { row: 1, .. })),
+                "{:?}",
+                text
+            );
+        }
+    }
 }
diff --git a/src/extension/arrow-ext/src/parquet/cells.rs b/src/extension/arrow-ext/src/parquet/cells.rs
index f5ce878e63..0c8ecd7ba0 100644
--- a/src/extension/arrow-ext/src/parquet/cells.rs
+++ b/src/extension/arrow-ext/src/parquet/cells.rs
@@ -7,6 +7,7 @@ use std::sync::Arc;
 use arrow_array::builder::{
     ArrayBuilder, BooleanBuilder, Date32Builder, DurationMicrosecondBuilder, FixedSizeBinaryBuilder, Float64Builder,
     Int64Builder, LargeBinaryBuilder, ListBuilder, MapBuilder, MapFieldNames, TimestampMicrosecondBuilder,
+    UInt64Builder,
 };
 use arrow_array::cast::AsArray;
 use arrow_array::types::{Date32Type, DurationMicrosecondType, Float64Type, Int64Type, TimestampMicrosecondType};
@@ -381,6 +382,7 @@ pub enum Scalar<'a> {
     Null,
     Bool(bool),
     Int(i64),
+    UInt(u64),
     Float(f64),
     Bytes(&'a [u8]),
     Uuid([u8; 16]),
@@ -396,6 +398,7 @@ impl Scalar<'_> {
             Scalar::Null => Scalar::Null,
             Scalar::Bool(value) => Scalar::Bool(value),
             Scalar::Int(value) => Scalar::Int(value),
+            Scalar::UInt(value) => Scalar::UInt(value),
             Scalar::Float(value) => Scalar::Float(value),
             Scalar::Bytes(_) => Scalar::Bytes(bytes),
             Scalar::Uuid(value) => Scalar::Uuid(value),
@@ -483,6 +486,7 @@ impl<'a> Checked<'a> for Validated<'a> {
 pub enum ColumnBuilder {
     Bool(BooleanBuilder),
     Int(Int64Builder),
+    UInt(UInt64Builder),
     Float(Float64Builder),
     Bytes(LargeBinaryBuilder),
     Uuid(FixedSizeBinaryBuilder),
@@ -532,6 +536,7 @@ impl ColumnBuilder {
         match canonical {
             DataType::Boolean => ColumnBuilder::Bool(BooleanBuilder::with_capacity(capacity)),
             DataType::Int64 => ColumnBuilder::Int(Int64Builder::with_capacity(capacity)),
+            DataType::UInt64 => ColumnBuilder::UInt(UInt64Builder::with_capacity(capacity)),
             DataType::Float64 => ColumnBuilder::Float(Float64Builder::with_capacity(capacity)),
             DataType::LargeBinary => ColumnBuilder::Bytes(LargeBinaryBuilder::with_capacity(capacity, 1024)),
             DataType::FixedSizeBinary(size) => {
@@ -584,6 +589,7 @@ impl ArrayBuilder for ColumnBuilder {
         match self {
             ColumnBuilder::Bool(builder) => builder.len(),
             ColumnBuilder::Int(builder) => builder.len(),
+            ColumnBuilder::UInt(builder) => builder.len(),
             ColumnBuilder::Float(builder) => builder.len(),
             ColumnBuilder::Bytes(builder) => builder.len(),
             ColumnBuilder::Uuid(builder) => builder.len(),
@@ -600,6 +606,7 @@ impl ArrayBuilder for ColumnBuilder {
         match self {
             ColumnBuilder::Bool(builder) => Arc::new(builder.finish()),
             ColumnBuilder::Int(builder) => Arc::new(builder.finish()),
+            ColumnBuilder::UInt(builder) => Arc::new(builder.finish()),
             ColumnBuilder::Float(builder) => Arc::new(builder.finish()),
             ColumnBuilder::Bytes(builder) => Arc::new(builder.finish()),
             ColumnBuilder::Uuid(builder) => Arc::new(builder.finish()),
@@ -616,6 +623,7 @@ impl ArrayBuilder for ColumnBuilder {
         match self {
             ColumnBuilder::Bool(builder) => Arc::new(builder.finish_cloned()),
             ColumnBuilder::Int(builder) => Arc::new(builder.finish_cloned()),
+            ColumnBuilder::UInt(builder) => Arc::new(builder.finish_cloned()),
             ColumnBuilder::Float(builder) => Arc::new(builder.finish_cloned()),
             ColumnBuilder::Bytes(builder) => Arc::new(builder.finish_cloned()),
             ColumnBuilder::Uuid(builder) => Arc::new(builder.finish_cloned()),
@@ -653,6 +661,8 @@ fn offsets_fit(current: usize, added: usize) -> bool {
 pub enum WriteCell {
     Bool,
     Int,
+    /// UINT_64: an int >= 0, or a canonical digit string up to 18446744073709551615.
+    UInt64,
     Float,
     /// DECIMAL: a float or an int.
     Decimal,
@@ -679,8 +689,8 @@ impl WriteCell {
             | DataType::Int64
             | DataType::UInt8
             | DataType::UInt16
-            | DataType::UInt32
-            | DataType::UInt64 => (WriteCell::Int, DataType::Int64),
+            | DataType::UInt32 => (WriteCell::Int, DataType::Int64),
+            DataType::UInt64 => (WriteCell::UInt64, DataType::UInt64),
             DataType::Float32 | DataType::Float64 => (WriteCell::Float, DataType::Float64),
             DataType::Decimal128(_, _) => (WriteCell::Decimal, DataType::Float64),
             DataType::Utf8 | DataType::Binary => (WriteCell::Bytes, DataType::LargeBinary),
@@ -754,6 +764,13 @@ impl WriteCell {
         Ok(match self {
             WriteCell::Bool => Scalar::Bool(value.bool().ok_or_else(|| refused("bool", value))?),
             WriteCell::Int => Scalar::Int(value.long().ok_or_else(|| refused("int", value))?),
+            WriteCell::UInt64 => Scalar::UInt(
+                match value.long() {
+                    Some(int) => u64::try_from(int).ok(),
+                    None => value.zend_str().and_then(|text| unsigned(text.as_bytes())),
+                }
+                .ok_or_else(|| refused(UNSIGNED_EXPECTED, value))?,
+            ),
             WriteCell::Float => Scalar::Float(value.double().ok_or_else(|| refused("float", value))?),
             WriteCell::Decimal => Scalar::Float(match (value.double(), value.long()) {
                 (Some(float), _) => float,
@@ -830,7 +847,7 @@ impl WriteCell {
                         }
                     }
 
-                    Ok(())
+                    Ok::<(), PhpException>(())
                 })?;
 
                 if let Some(refusal) = failure {
@@ -846,7 +863,7 @@ impl WriteCell {
 
                 ht_for_each(items, |name, index, item| {
                     if failure.is_some() {
-                        return Ok(());
+                        return Ok::<(), PhpException>(());
                     }
 
                     let entry_key = match name {
@@ -986,6 +1003,7 @@ impl WriteCell {
             (_, builder, Scalar::Null) => self.append_null(builder),
             (WriteCell::Bool, ColumnBuilder::Bool(builder), Scalar::Bool(value)) => builder.append_value(*value),
             (WriteCell::Int, ColumnBuilder::Int(builder), Scalar::Int(value)) => builder.append_value(*value),
+            (WriteCell::UInt64, ColumnBuilder::UInt(builder), Scalar::UInt(value)) => builder.append_value(*value),
             (WriteCell::Float | WriteCell::Decimal, ColumnBuilder::Float(builder), Scalar::Float(value)) => {
                 builder.append_value(*value);
             }
@@ -1022,6 +1040,7 @@ impl WriteCell {
             }
             (_, ColumnBuilder::Bool(builder)) => builder.append_null(),
             (_, ColumnBuilder::Int(builder)) => builder.append_null(),
+            (_, ColumnBuilder::UInt(builder)) => builder.append_null(),
             (_, ColumnBuilder::Float(builder)) => builder.append_null(),
             (_, ColumnBuilder::Bytes(builder)) => builder.append_null(),
             (_, ColumnBuilder::Uuid(builder)) => builder.append_null(),
@@ -1037,6 +1056,18 @@ impl WriteCell {
     }
 }
 
+/// What a UINT_64 cell takes, as its refusals name it.
+pub const UNSIGNED_EXPECTED: &str = "int >= 0 or digit string";
+
+/// A canonical digit string (no sign, no leading zero) within u64, as `UnsignedInt64Converter::toParquetType()` takes it.
+pub fn unsigned(text: &[u8]) -> Option<u64> {
+    if text.is_empty() || !text.iter().all(u8::is_ascii_digit) || (text.len() > 1 && text[0] == b'0') {
+        return None;
+    }
+
+    std::str::from_utf8(text).ok()?.parse().ok()
+}
+
 /// `UuidConverter::toParquetType()`'s text of an object: `toString()`, else `__toString()`; `None` for neither.
 fn uuid_text_of(object: &ZendObject) -> Result<Option<Zval>, PhpException> {
     let ce = unsafe { object.ce.as_ref() }.ok_or_else(|| ext_exception("arrow expected a class entry"))?;
diff --git a/src/extension/arrow-ext/src/parquet/chunks.rs b/src/extension/arrow-ext/src/parquet/chunks.rs
new file mode 100644
index 0000000000..c16c830449
--- /dev/null
+++ b/src/extension/arrow-ext/src/parquet/chunks.rs
@@ -0,0 +1,335 @@
+//! The column chunks of the leaves a filter reads and their column orders, sliced from the footer's thrift bytes
+//! as the file holds them: the PHP planner decodes the bytes the PHP engine decodes, so both engines prune alike.
+
+use std::ops::Range;
+
+use crate::parquet::error::Error;
+use crate::thrift::{elements as list, fields, Field, Malformed};
+
+const FILE_ROW_GROUPS: i16 = 4;
+const FILE_COLUMN_ORDERS: i16 = 7;
+const FILE_ENCRYPTION_ALGORITHM: i16 = 8;
+const ROW_GROUP_COLUMNS: i16 = 1;
+const CHUNK_CRYPTO_METADATA: i16 = 8;
+const CHUNK_ENCRYPTED_COLUMN_METADATA: i16 = 9;
+
+/// Byte ranges into the footer, one entry per leaf asked for, in the order asked.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ChunkSpans {
+    /// Each leaf's `ColumnChunk` in every row group, in file order.
+    pub chunks: Vec<Vec<Range<usize>>>,
+    /// Each leaf's `ColumnOrder`; `None` when the file has no `column_orders`.
+    pub orders: Option<Vec<Range<usize>>>,
+}
+
+/// `leaves`: indices into the schema's leaves.
+pub fn chunk_spans(footer: &[u8], leaves: &[usize]) -> Result<ChunkSpans, Error> {
+    let mut chunks = vec![Vec::new(); leaves.len()];
+    let mut orders = None;
+
+    for field in fields(footer) {
+        let field = field.map_err(malformed)?;
+
+        match field.id {
+            FILE_ROW_GROUPS => {
+                for group in elements(footer, &field, 0)? {
+                    let group = group?;
+                    let columns = row_group_columns(footer, &group)?.collect::<Result<Vec<_>, _>>()?;
+
+                    for (position, leaf) in leaves.iter().enumerate() {
+                        chunks[position].push(
+                            columns
+                                .get(*leaf)
+                                .cloned()
+                                .ok_or_else(|| corrupt("a row group without the leaf"))?,
+                        );
+                    }
+                }
+            }
+            FILE_COLUMN_ORDERS => {
+                let columns = elements(footer, &field, 0)?.collect::<Result<Vec<_>, _>>()?;
+
+                orders = Some(
+                    leaves
+                        .iter()
+                        .map(|leaf| {
+                            columns
+                                .get(*leaf)
+                                .cloned()
+                                .ok_or_else(|| corrupt("column orders without the leaf"))
+                        })
+                        .collect::<Result<Vec<_>, _>>()?,
+                );
+            }
+            _ => {}
+        }
+    }
+
+    Ok(ChunkSpans { chunks, orders })
+}
+
+/// Refuses a footer that holds an encryption algorithm or an encrypted column chunk: arrow-rs decodes a plaintext
+/// footer with encrypted columns without a word.
+pub fn refuse_encrypted(footer: &[u8]) -> Result<(), Error> {
+    for field in fields(footer) {
+        let field = field.map_err(malformed)?;
+
+        match field.id {
+            FILE_ROW_GROUPS => {
+                for group in elements(footer, &field, 0)? {
+                    for chunk in row_group_columns(footer, &group?)? {
+                        for field in fields(&footer[chunk?]) {
+                            let field = field.map_err(malformed)?;
+
+                            if field.id == CHUNK_CRYPTO_METADATA || field.id == CHUNK_ENCRYPTED_COLUMN_METADATA {
+                                return Err(Error::Encrypted);
+                            }
+                        }
+                    }
+                }
+            }
+            FILE_ENCRYPTION_ALGORITHM => return Err(Error::Encrypted),
+            _ => {}
+        }
+    }
+
+    Ok(())
+}
+
+/// The `ColumnChunk`s of the row group at `group` in `footer`, as ranges into `footer`.
+fn row_group_columns<'a>(
+    footer: &'a [u8],
+    group: &Range<usize>,
+) -> Result<impl Iterator<Item = Result<Range<usize>, Error>> + 'a, Error> {
+    let mut columns = None;
+
+    for field in fields(&footer[group.clone()]) {
+        let field = field.map_err(malformed)?;
+
+        if field.id == ROW_GROUP_COLUMNS {
+            columns = Some(field);
+            break;
+        }
+    }
+
+    elements(
+        footer,
+        &columns.ok_or_else(|| corrupt("a row group without columns"))?,
+        group.start,
+    )
+}
+
+/// The elements of the list `field` holds, `field` read from the struct at `offset` in `footer`, as ranges into
+/// `footer`.
+fn elements<'a>(
+    footer: &'a [u8],
+    field: &Field,
+    offset: usize,
+) -> Result<impl Iterator<Item = Result<Range<usize>, Error>> + 'a, Error> {
+    if !field.is_list() {
+        return Err(corrupt("another value where a list belongs"));
+    }
+
+    let start = offset + field.value.start;
+
+    Ok(list(&footer[start..offset + field.value.end])
+        .map_err(malformed)?
+        .map(move |element| {
+            element
+                .map(|element| element.start + start..element.end + start)
+                .map_err(malformed)
+        }))
+}
+
+fn corrupt(what: &str) -> Error {
+    Error::NotParquet(format!("Invalid Parquet file. The footer holds {what}"))
+}
+
+fn malformed(malformed: Malformed) -> Error {
+    Error::NotParquet(format!(
+        "Invalid Parquet file. The footer is not thrift: {}",
+        malformed.0
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::{ArrayRef, Int64Array, RecordBatch, StringArray};
+    use arrow_schema::{DataType, Field, Schema};
+    use bytes::Bytes;
+    use parquet::arrow::ArrowWriter;
+    use parquet::file::properties::WriterProperties;
+
+    use super::{chunk_spans, refuse_encrypted};
+    use crate::parquet::error::Error;
+    use crate::parquet::footer::Footer;
+    use crate::thrift::{elements, fields};
+
+    /// `id` Int64 and `name` Utf8 in two row groups of 2 rows.
+    fn two_groups() -> Footer {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Int64, false),
+            Field::new("name", DataType::Utf8, true),
+        ]));
+        let mut file = Vec::new();
+        let mut writer = ArrowWriter::try_new(
+            &mut file,
+            Arc::clone(&schema),
+            Some(WriterProperties::builder().set_max_row_group_row_count(Some(2)).build()),
+        )
+        .unwrap();
+        writer
+            .write(
+                &RecordBatch::try_new(
+                    schema,
+                    vec![
+                        Arc::new(Int64Array::from(vec![1, 2, 3, 4])) as ArrayRef,
+                        Arc::new(StringArray::from(vec!["a", "b", "c", "d"])),
+                    ],
+                )
+                .unwrap(),
+            )
+            .unwrap();
+        writer.close().unwrap();
+
+        Footer::read(&Bytes::from(file)).unwrap()
+    }
+
+    /// `bytes` with `insert` put at `at` and the `remove` bytes after it dropped.
+    fn spliced(bytes: &[u8], at: usize, remove: usize, insert: &[u8]) -> Vec<u8> {
+        let mut spliced = bytes[..at].to_vec();
+        spliced.extend_from_slice(insert);
+        spliced.extend_from_slice(&bytes[at + remove..]);
+
+        spliced
+    }
+
+    /// The footer with `field` (of compact wire type `wire`, then `value`) appended to the first chunk of `id`.
+    fn with_chunk_field(bytes: &[u8], field: u8, wire: u8, value: &[u8]) -> Vec<u8> {
+        let chunk = chunk_spans(bytes, &[0]).unwrap().chunks[0][0].clone();
+        let last = fields(&bytes[chunk.clone()]).last().unwrap().unwrap().id as u8;
+        let mut insert = vec![((field - last) << 4) | wire];
+        insert.extend_from_slice(value);
+
+        spliced(bytes, chunk.end - 1, 0, &insert)
+    }
+
+    fn assert_corrupt(result: Result<super::ChunkSpans, Error>, message: &str) {
+        match result {
+            Err(Error::NotParquet(actual)) => assert!(actual.contains(message), "{actual}"),
+            other => panic!("expected NotParquet containing {message:?}, got {other:?}"),
+        }
+    }
+
+    /// `ColumnChunk.meta_data.path_in_schema` of the chunk `span` holds.
+    fn path(footer: &[u8], span: &std::ops::Range<usize>) -> Vec<u8> {
+        let chunk = &footer[span.clone()];
+        let meta = fields(chunk)
+            .map(Result::unwrap)
+            .find(|field| field.id == 3)
+            .unwrap()
+            .value;
+        let path = fields(&chunk[meta.clone()])
+            .map(Result::unwrap)
+            .find(|field| field.id == 3)
+            .unwrap()
+            .value;
+        let elements = elements(&chunk[meta.start + path.start..meta.start + path.end])
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+
+        chunk[meta.start + path.start + elements[0].start + 1..meta.start + path.start + elements[0].end].to_vec()
+    }
+
+    #[test]
+    fn the_spans_are_each_asked_leafs_chunk_per_row_group_and_its_column_order() {
+        let footer = two_groups();
+        let bytes = footer.bytes();
+        let spans = chunk_spans(bytes, &[1, 0]).unwrap();
+
+        assert_eq!(spans.chunks.len(), 2);
+        assert_eq!(spans.chunks[0].len(), 2);
+        assert_eq!(spans.chunks[1].len(), 2);
+        assert_eq!(path(bytes, &spans.chunks[0][0]), b"name");
+        assert_eq!(path(bytes, &spans.chunks[0][1]), b"name");
+        assert_eq!(path(bytes, &spans.chunks[1][1]), b"id");
+
+        let orders = spans.orders.unwrap();
+
+        // a ColumnOrder union holding TYPE_ORDER (field 1, an empty struct)
+        assert_eq!(&bytes[orders[0].clone()], b"\x1c\x00\x00");
+        assert_eq!(&bytes[orders[1].clone()], b"\x1c\x00\x00");
+    }
+
+    #[test]
+    fn a_file_without_column_orders_has_no_orders() {
+        let footer = two_groups();
+        let bytes = footer.bytes();
+        let orders = fields(bytes)
+            .map(Result::unwrap)
+            .find(|field| field.id == 7)
+            .unwrap()
+            .value;
+
+        // column_orders is the last field: its header is one byte, delta 1 and wire type LIST
+        assert_eq!(bytes[orders.start - 1], 0x19);
+
+        let without = spliced(bytes, orders.start - 1, orders.len() + 1, &[]);
+        let spans = chunk_spans(&without, &[1]).unwrap();
+
+        assert_eq!(spans.orders, None);
+        assert_eq!(path(&without, &spans.chunks[0][1]), b"name");
+    }
+
+    #[test]
+    fn a_row_group_without_the_asked_leaf_is_corrupt() {
+        assert_corrupt(chunk_spans(two_groups().bytes(), &[2]), "a row group without the leaf");
+    }
+
+    #[test]
+    fn a_truncated_footer_is_not_thrift() {
+        let footer = two_groups();
+        let bytes = footer.bytes();
+
+        assert_corrupt(chunk_spans(&bytes[..bytes.len() / 2], &[0]), "The footer is not thrift");
+    }
+
+    #[test]
+    fn a_list_field_of_another_wire_type_is_corrupt() {
+        // row_groups (field 4) as the i32 1: header delta 4, wire type I32, zigzag 2, then the struct's stop
+        assert_corrupt(chunk_spans(b"\x45\x02\x00", &[0]), "another value where a list belongs");
+    }
+
+    #[test]
+    fn an_encrypted_column_chunk_is_refused() {
+        let footer = two_groups();
+        let bytes = footer.bytes();
+
+        // crypto_metadata (8): ENCRYPTION_WITH_FOOTER_KEY, an empty struct in a union
+        assert!(matches!(
+            refuse_encrypted(&with_chunk_field(bytes, 8, 12, b"\x1c\x00\x00")),
+            Err(Error::Encrypted)
+        ));
+        // encrypted_column_metadata (9): one byte of binary
+        assert!(matches!(
+            refuse_encrypted(&with_chunk_field(bytes, 9, 8, b"\x01\xaa")),
+            Err(Error::Encrypted)
+        ));
+        assert!(refuse_encrypted(bytes).is_ok());
+    }
+
+    #[test]
+    fn an_encryption_algorithm_is_refused() {
+        let footer = two_groups();
+        let bytes = footer.bytes();
+
+        // encryption_algorithm (8) after column_orders (7): AES_GCM_V1, an empty struct in a union
+        assert!(matches!(
+            refuse_encrypted(&spliced(bytes, bytes.len() - 1, 0, b"\x1c\x1c\x00\x00")),
+            Err(Error::Encrypted)
+        ));
+    }
+}
diff --git a/src/extension/arrow-ext/src/parquet/error.rs b/src/extension/arrow-ext/src/parquet/error.rs
index 4817f37754..81ec31eebb 100644
--- a/src/extension/arrow-ext/src/parquet/error.rs
+++ b/src/extension/arrow-ext/src/parquet/error.rs
@@ -42,6 +42,11 @@ pub enum Error {
     /// Bytes that are not a Parquet file: no footer where it must be.
     NotParquet(String),
     Options(String),
+    /// A read plan arrow cannot follow: selectors that do not cover the file's rows, a malformed limit or row filter,
+    /// a row filter path that is no leaf of the file or bounds its column cannot take.
+    Plan(String),
+    /// A footer or a column chunk encrypted with Parquet modular encryption.
+    Encrypted,
     Stream(String),
 }
 
diff --git a/src/extension/arrow-ext/src/parquet/fetch.rs b/src/extension/arrow-ext/src/parquet/fetch.rs
deleted file mode 100644
index ce141cc755..0000000000
--- a/src/extension/arrow-ext/src/parquet/fetch.rs
+++ /dev/null
@@ -1,328 +0,0 @@
-//! A planned read's column chunks, fetched a row group at a time: the first page request inside a planned row group
-//! reads every projected column chunk of that group - adjacent chunks in one read - and every later page header and
-//! page body of the group is a slice of those buffers. arrow-rs's sync page reader asks for each page header
-//! separately (`get_read`), so answering from the stream per request would read the file many times over.
-//!
-//! arrow-rs advances each column's pages on its own, so one batch may take column `a` into the next row group while
-//! column `b` still reads the previous one: a group's buffers are dropped once every projected column has moved past
-//! it. Memory: the projected compressed chunks of the row groups one batch spans - the bound arrow-rs's async reader
-//! and DuckDB accept, row groups being the writer's unit.
-
-use std::collections::btree_map::Entry;
-use std::collections::BTreeMap;
-use std::ops::Range;
-use std::sync::{Arc, Mutex};
-
-use bytes::buf::Reader;
-use bytes::{Buf, Bytes};
-use parquet::errors::ParquetError;
-use parquet::file::metadata::ParquetMetaData;
-use parquet::file::reader::{ChunkReader, Length};
-
-use crate::parquet::source::{exact, ReadAt};
-
-/// A column chunk of the file and, when the read plans it, where: its planned group, its projected column, and the
-/// coalesced read of that group holding it.
-struct Chunk {
-    range: Range<u64>,
-    planned: Option<(usize, usize, usize)>,
-}
-
-#[derive(Default)]
-struct Fetched {
-    /// Planned group → its reads' bytes.
-    buffers: BTreeMap<usize, Vec<Bytes>>,
-    /// Per projected column, the planned group it reads now.
-    progress: Vec<usize>,
-}
-
-pub struct ChunkFetch<R> {
-    source: Arc<R>,
-    size: u64,
-    /// Per planned group, its projected chunks with every run of adjacent ones merged, in file order.
-    reads: Vec<Vec<Range<u64>>>,
-    /// Every column chunk of the file, by start: page requests find theirs by binary search.
-    chunks: Vec<Chunk>,
-    fetched: Mutex<Fetched>,
-}
-
-impl<R: ReadAt> ChunkFetch<R> {
-    /// `row_groups`: the planned groups; `leaves`: the projected leaf columns.
-    pub fn new(source: Arc<R>, size: u64, meta: &ParquetMetaData, row_groups: &[usize], leaves: &[usize]) -> Self {
-        let range = |(start, length): (u64, u64)| start..start + length;
-        let planned = row_groups
-            .iter()
-            .map(|group| {
-                let columns = meta.row_group(*group).columns();
-
-                leaves.iter().map(|leaf| range(columns[*leaf].byte_range())).collect()
-            })
-            .collect();
-        let mut is_planned = vec![false; meta.num_row_groups()];
-        let mut is_projected = vec![false; meta.file_metadata().schema_descr().num_columns()];
-        row_groups.iter().for_each(|group| is_planned[*group] = true);
-        leaves.iter().for_each(|leaf| is_projected[*leaf] = true);
-        let (is_planned, is_projected) = (&is_planned, &is_projected);
-        let unplanned = meta
-            .row_groups()
-            .iter()
-            .enumerate()
-            .flat_map(|(group, columns)| {
-                columns
-                    .columns()
-                    .iter()
-                    .enumerate()
-                    .filter(move |(leaf, _)| !is_planned[group] || !is_projected[*leaf])
-                    .map(|(_, chunk)| range(chunk.byte_range()))
-            })
-            .collect();
-
-        Self::from_ranges(source, size, planned, unplanned)
-    }
-
-    /// `planned`: per planned group, its projected chunks, by projected column; `unplanned`: every other chunk.
-    fn from_ranges(source: Arc<R>, size: u64, planned: Vec<Vec<Range<u64>>>, unplanned: Vec<Range<u64>>) -> Self {
-        let columns = planned.first().map_or(0, Vec::len);
-        let reads = planned
-            .iter()
-            .map(|chunks| coalesced(chunks.clone()))
-            .collect::<Vec<_>>();
-        let mut chunks = unplanned
-            .into_iter()
-            .map(|range| Chunk { range, planned: None })
-            .chain(planned.into_iter().enumerate().flat_map(|(group, chunks)| {
-                let reads = &reads[group];
-
-                chunks
-                    .into_iter()
-                    .enumerate()
-                    .map(move |(column, range)| {
-                        let read = reads
-                            .iter()
-                            .position(|read| read.start <= range.start && range.end <= read.end);
-
-                        Chunk {
-                            planned: read.map(|read| (group, column, read)),
-                            range,
-                        }
-                    })
-                    .collect::<Vec<_>>()
-            }))
-            .collect::<Vec<_>>();
-        chunks.sort_by_key(|chunk| chunk.range.start);
-
-        Self {
-            source,
-            size,
-            reads,
-            chunks,
-            fetched: Mutex::new(Fetched {
-                buffers: BTreeMap::new(),
-                progress: vec![0; columns],
-            }),
-        }
-    }
-
-    /// The column chunk holding `offset`.
-    fn chunk_at(&self, offset: u64) -> Option<&Chunk> {
-        let after = self.chunks.partition_point(|chunk| chunk.range.start <= offset);
-
-        after
-            .checked_sub(1)
-            .map(|index| &self.chunks[index])
-            .filter(|chunk| offset < chunk.range.end)
-    }
-
-    /// The fetched bytes of [start, end) when a planned column chunk holds it, fetching its row group first.
-    fn planned(&self, start: u64, end: u64) -> Result<Option<Bytes>, ParquetError> {
-        let Some((group, column, read)) = self.chunk_at(start).and_then(|chunk| chunk.planned) else {
-            return Ok(None);
-        };
-        let range = &self.reads[group][read];
-
-        if end > range.end {
-            return Ok(None);
-        }
-
-        let mut fetched = self
-            .fetched
-            .lock()
-            .map_err(|_| ParquetError::General("chunk fetch poisoned".into()))?;
-
-        if let Entry::Vacant(entry) = fetched.buffers.entry(group) {
-            entry.insert(
-                self.reads[group]
-                    .iter()
-                    .map(|range| exact(self.source.as_ref(), range.start, (range.end - range.start) as usize))
-                    .collect::<Result<Vec<_>, _>>()?,
-            );
-        }
-
-        let bytes = fetched.buffers[&group][read].slice((start - range.start) as usize..(end - range.start) as usize);
-        fetched.progress[column] = group;
-        let slowest = fetched.progress.iter().copied().min().unwrap_or(group);
-        fetched.buffers.retain(|fetched_group, _| *fetched_group >= slowest);
-
-        Ok(Some(bytes))
-    }
-}
-
-/// Sorted ranges with every run of adjacent ones merged.
-fn coalesced(mut ranges: Vec<Range<u64>>) -> Vec<Range<u64>> {
-    ranges.sort_by_key(|range| range.start);
-    let mut merged: Vec<Range<u64>> = Vec::with_capacity(ranges.len());
-
-    for range in ranges {
-        match merged.last_mut() {
-            Some(last) if last.end == range.start => last.end = range.end,
-            _ => merged.push(range),
-        }
-    }
-
-    merged
-}
-
-impl<R> Length for ChunkFetch<R> {
-    fn len(&self) -> u64 {
-        self.size
-    }
-}
-
-impl<R: ReadAt + Send + Sync> ChunkReader for ChunkFetch<R> {
-    type T = Reader<Bytes>;
-
-    /// A page header: the rest of its planned read; outside the plan, one exact read to the end of the column chunk
-    /// holding `start` (of the file when none does).
-    fn get_read(&self, start: u64) -> Result<Self::T, ParquetError> {
-        let end = self.chunk_at(start).map_or(self.size, |chunk| match chunk.planned {
-            Some((group, _, read)) => self.reads[group][read].end,
-            None => chunk.range.end,
-        });
-
-        Ok(match self.planned(start, end)? {
-            Some(bytes) => bytes,
-            None => exact(self.source.as_ref(), start, (end - start) as usize)?,
-        }
-        .reader())
-    }
-
-    fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes, ParquetError> {
-        match self.planned(start, start + length as u64)? {
-            Some(bytes) => Ok(bytes),
-            None => exact(self.source.as_ref(), start, length),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io::Read;
-    use std::ops::Range;
-    use std::sync::Arc;
-
-    use parquet::file::reader::ChunkReader;
-
-    use super::{coalesced, ChunkFetch};
-    use crate::parquet::source::fake::Counting;
-
-    #[test]
-    fn adjacent_ranges_are_coalesced() {
-        assert_eq!(coalesced(vec![10..20, 0..10, 30..40, 20..25]), vec![0..25, 30..40]);
-        assert!(coalesced(vec![]).is_empty());
-    }
-
-    fn fetch(
-        source: &Arc<Counting>,
-        planned: Vec<Vec<Range<u64>>>,
-        unplanned: Vec<Range<u64>>,
-    ) -> ChunkFetch<Counting> {
-        ChunkFetch::from_ranges(Arc::clone(source), source.data.len() as u64, planned, unplanned)
-    }
-
-    #[test]
-    fn a_read_outside_the_plan_is_one_exact_read_to_the_end_of_its_chunk() {
-        let source = Arc::new(Counting::new((0..100).collect()));
-        let fetch = fetch(&source, vec![vec![10..20]], vec![30..35, 40..60]);
-        let mut rest = Vec::new();
-
-        fetch.get_read(45).unwrap().read_to_end(&mut rest).unwrap();
-
-        assert_eq!(rest, (45..60).collect::<Vec<u8>>());
-        assert_eq!(source.counted(), (1, 15));
-
-        rest.clear();
-        fetch.get_read(90).unwrap().read_to_end(&mut rest).unwrap();
-
-        assert_eq!(rest, (90..100).collect::<Vec<u8>>());
-        assert_eq!(fetch.get_bytes(70, 2).unwrap().to_vec(), vec![70, 71]);
-        assert_eq!(source.counted(), (3, 27));
-    }
-
-    #[test]
-    fn a_planned_group_is_fetched_once_in_coalesced_reads() {
-        let source = Arc::new(Counting::new((0..100).collect()));
-        let fetch = fetch(&source, vec![vec![0..10, 10..15, 20..30]], vec![]);
-        let mut header = Vec::new();
-
-        assert_eq!(fetch.get_bytes(22, 3).unwrap().to_vec(), vec![22, 23, 24]);
-        fetch.get_read(12).unwrap().read_to_end(&mut header).unwrap();
-        assert_eq!(fetch.get_bytes(1, 2).unwrap().to_vec(), vec![1, 2]);
-
-        assert_eq!(header, (12..15).collect::<Vec<u8>>());
-        assert_eq!(source.counted(), (2, 25));
-    }
-
-    #[test]
-    fn a_group_is_dropped_once_every_column_moved_past_it() {
-        let source = Arc::new(Counting::new((0..100).collect()));
-        let fetch = fetch(&source, vec![vec![0..10, 20..30], vec![50..60, 70..80]], vec![]);
-        let groups = |fetch: &ChunkFetch<Counting>| {
-            fetch
-                .fetched
-                .lock()
-                .unwrap()
-                .buffers
-                .keys()
-                .copied()
-                .collect::<Vec<_>>()
-        };
-
-        fetch.get_bytes(0, 1).unwrap();
-        fetch.get_bytes(50, 1).unwrap();
-        assert_eq!(groups(&fetch), vec![0, 1]);
-
-        fetch.get_bytes(21, 1).unwrap();
-        assert_eq!(groups(&fetch), vec![0, 1]);
-
-        fetch.get_bytes(71, 1).unwrap();
-        assert_eq!(groups(&fetch), vec![1]);
-        assert_eq!(source.counted(), (4, 40));
-    }
-
-    #[test]
-    fn page_requests_find_their_chunk_among_many() {
-        let source = Arc::new(Counting::new((0..=255).cycle().take(40_000).collect()));
-        let planned = (0..100).map(|group| vec![group * 400..group * 400 + 100, group * 400 + 200..group * 400 + 300]);
-        let fetch = fetch(
-            &source,
-            planned.collect(),
-            (0..100).map(|group| group * 400 + 100..group * 400 + 200).collect(),
-        );
-
-        assert_eq!(
-            fetch.get_bytes(99 * 400 + 250, 2).unwrap().to_vec(),
-            source.data[39_850..39_852].to_vec()
-        );
-        assert_eq!(source.counted(), (2, 200));
-
-        let mut header = Vec::new();
-        fetch
-            .get_read(50 * 400 + 150)
-            .unwrap()
-            .read_to_end(&mut header)
-            .unwrap();
-
-        assert_eq!(header, source.data[20_150..20_200].to_vec());
-        assert_eq!(source.counted(), (3, 250));
-    }
-}
diff --git a/src/extension/arrow-ext/src/parquet/filter.rs b/src/extension/arrow-ext/src/parquet/filter.rs
new file mode 100644
index 0000000000..a1d269de30
--- /dev/null
+++ b/src/extension/arrow-ext/src/parquet/filter.rs
@@ -0,0 +1,1234 @@
+//! The row filter `ReadPlanConverter::toExtension()` sends as `'filter'`, evaluated by arrow-rs's push decoder on the
+//! predicate leaves of each row group before the projected leaves are decoded, one predicate per root conjunct. A row
+//! is kept only when the filter is TRUE: `Not` is pushed down to the leaves as a polarity, so every node yields the
+//! rows it is TRUE for, and a NULL (a null value, an absent column) is TRUE in neither polarity. Floats compare as
+//! IEEE 754: NaN is false, -0.0 equals +0.0.
+
+use std::cmp::Ordering;
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::{
+    Date32Type, Date64Type, Decimal128Type, Decimal256Type, Float32Type, Float64Type, Int16Type, Int32Type, Int64Type,
+    Int8Type, Time32MillisecondType, Time32SecondType, Time64MicrosecondType, Time64NanosecondType,
+    TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, UInt16Type,
+    UInt32Type, UInt64Type, UInt8Type,
+};
+use arrow_array::{Array, ArrayRef, ArrowPrimitiveType, BooleanArray, RecordBatch};
+use arrow_buffer::{i256, BooleanBuffer};
+use arrow_schema::{ArrowError, DataType, Schema, TimeUnit};
+use parquet::arrow::arrow_reader::ArrowPredicate;
+use parquet::arrow::ProjectionMask;
+use parquet::basic::{ConvertedType, LogicalType, Type};
+use parquet::schema::types::{ColumnDescriptor, SchemaDescriptor};
+
+use crate::parquet::error::Error;
+use crate::parquet::read::{struct_child, struct_field};
+
+/// A PHP value as the converter's array holds it.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Raw {
+    Null,
+    Bool(bool),
+    Int(i64),
+    Float(f64),
+    Bytes(Vec<u8>),
+    List(Vec<Raw>),
+    Map(Vec<(Vec<u8>, Raw)>),
+}
+
+/// A physical bound as PHP sends it: INT32/INT64 values (the UINT_64 bit pattern included), floats, booleans, bytes
+/// (BYTE_ARRAY, FIXED_LEN_BYTE_ARRAY, DECIMAL unscaled big-endian two's complement).
+#[derive(Debug, Clone, PartialEq)]
+enum Scalar {
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    Bytes(Vec<u8>),
+}
+
+/// A null bound is unbounded.
+#[derive(Debug, Clone, PartialEq)]
+struct Interval<T> {
+    lower: Option<T>,
+    lower_inclusive: bool,
+    upper: Option<T>,
+    upper_inclusive: bool,
+}
+
+/// Per row of a leaf, whether its value matches; a null row's slot holds no value and is masked by its caller.
+type Matcher = Box<dyn Fn(&ArrayRef) -> BooleanBuffer + Send>;
+
+/// The `ArrowPredicate` of one root conjunct, checked against the file's arrow schema when built.
+pub struct PlanPredicate {
+    leaves: Vec<usize>,
+    mask: ProjectionMask,
+    root: Compiled,
+}
+
+impl PlanPredicate {
+    /// One predicate per root conjunct of `filter`, in order: arrow-rs evaluates each on the rows the ones before kept.
+    pub fn conjuncts(filter: &Raw, schema: &Schema, descr: &SchemaDescriptor) -> Result<Vec<Self>, Error> {
+        conjuncts(filter)?
+            .into_iter()
+            .map(|conjunct| {
+                let mut leaves = Vec::new();
+                let root = Compiled::parse(conjunct, schema, descr, &mut leaves)?;
+
+                Ok(Self {
+                    mask: ProjectionMask::leaves(descr, leaves.iter().copied()),
+                    leaves,
+                    root,
+                })
+            })
+            .collect()
+    }
+
+    /// The parquet leaf of each path the conjunct reads.
+    pub fn leaves(&self) -> &[usize] {
+        &self.leaves
+    }
+}
+
+impl ArrowPredicate for PlanPredicate {
+    fn projection(&self) -> &ProjectionMask {
+        &self.mask
+    }
+
+    fn evaluate(&mut self, batch: RecordBatch) -> Result<BooleanArray, ArrowError> {
+        Ok(BooleanArray::new(self.root.truth(&batch, false)?, None))
+    }
+}
+
+/// A filter node with each leaf's match typed for the arrow array the leaf is read as.
+enum Compiled {
+    And(Vec<Compiled>),
+    Or(Vec<Compiled>),
+    Not(Box<Compiled>),
+    Matches {
+        path: Vec<String>,
+        matcher: Matcher,
+    },
+    IsNull {
+        path: Vec<String>,
+    },
+    /// A leaf on a column absent from the file, null in every row: TRUE for an IS NULL, NULL for any other leaf.
+    Absent {
+        is_null: bool,
+    },
+}
+
+impl Compiled {
+    /// `leaves` gains the parquet leaf of each path the node reads, once.
+    fn parse(raw: &Raw, schema: &Schema, descr: &SchemaDescriptor, leaves: &mut Vec<usize>) -> Result<Self, Error> {
+        let entries = map(raw, "a filter node")?;
+        let mut children = |raw: &Raw, what: &str| {
+            list(raw, what)?
+                .iter()
+                .map(|child| Self::parse(child, schema, descr, leaves))
+                .collect::<Result<Vec<_>, _>>()
+        };
+
+        if let [(key, value)] = entries {
+            match key.as_slice() {
+                b"and" => return Ok(Self::And(children(value, "'and'")?)),
+                b"or" => return Ok(Self::Or(children(value, "'or'")?)),
+                b"not" => return Ok(Self::Not(Box::new(Self::parse(value, schema, descr, leaves)?))),
+                _ => {}
+            }
+        }
+
+        Ok(match field(entries, b"leaf")? {
+            Raw::Bytes(kind) if kind == b"intervals" => {
+                let path = path(field(entries, b"path")?)?;
+                let intervals = list(field(entries, b"intervals")?, "'intervals'")?
+                    .iter()
+                    .map(interval)
+                    .collect::<Result<Vec<_>, _>>()?;
+                let column = descr.column(leaf(descr, &path, leaves)?);
+
+                Self::Matches {
+                    matcher: bounds(&column, &path, &intervals, &data_type(schema, &path)?)?,
+                    path,
+                }
+            }
+            Raw::Bytes(kind) if kind == b"is_null" => {
+                let path = path(field(entries, b"path")?)?;
+                leaf(descr, &path, leaves)?;
+                data_type(schema, &path)?;
+
+                Self::IsNull { path }
+            }
+            Raw::Bytes(kind) if kind == b"starts_with" => {
+                let path = path(field(entries, b"path")?)?;
+                let prefix = match field(entries, b"prefix")? {
+                    Raw::Bytes(prefix) => prefix.clone(),
+                    other => return Err(malformed(format!("a prefix must be a string, got {other:?}"))),
+                };
+                leaf(descr, &path, leaves)?;
+                let data_type = data_type(schema, &path)?;
+
+                Self::Matches {
+                    matcher: by_bytes(
+                        ByteArray::of(&data_type).ok_or_else(|| unsupported(&path, &data_type))?,
+                        move |value| value.starts_with(&prefix),
+                    ),
+                    path,
+                }
+            }
+            Raw::Bytes(kind) if kind == b"absent" => Self::Absent {
+                is_null: match field(entries, b"is_null")? {
+                    Raw::Bool(is_null) => *is_null,
+                    other => return Err(malformed(format!("'is_null' must be a bool, got {other:?}"))),
+                },
+            },
+            leaf => return Err(malformed(format!("unknown leaf {leaf:?}"))),
+        })
+    }
+
+    /// The rows the node is TRUE for: under `negated`, the rows its negation is TRUE for.
+    fn truth(&self, batch: &RecordBatch, negated: bool) -> Result<BooleanBuffer, ArrowError> {
+        let rows = batch.num_rows();
+
+        Ok(match self {
+            Self::And(children) | Self::Or(children) => {
+                let conjunction = matches!(self, Self::And(_)) != negated;
+                let mut result = if conjunction {
+                    BooleanBuffer::new_set(rows)
+                } else {
+                    BooleanBuffer::new_unset(rows)
+                };
+
+                for child in children {
+                    let truth = child.truth(batch, negated)?;
+                    result = if conjunction {
+                        &result & &truth
+                    } else {
+                        &result | &truth
+                    };
+                }
+
+                result
+            }
+            Self::Not(child) => child.truth(batch, !negated)?,
+            Self::Absent { is_null } if *is_null && !negated => BooleanBuffer::new_set(rows),
+            Self::Absent { .. } => BooleanBuffer::new_unset(rows),
+            Self::IsNull { path } => {
+                let (_, valid) = column(batch, path)?;
+
+                if negated {
+                    valid
+                } else {
+                    !&valid
+                }
+            }
+            Self::Matches { path, matcher } => {
+                let (array, valid) = column(batch, path)?;
+                let matches = matcher(&array);
+
+                if negated {
+                    &valid & &!&matches
+                } else {
+                    &valid & &matches
+                }
+            }
+        })
+    }
+}
+
+/// The root conjuncts of a filter, nested `and`s flattened.
+fn conjuncts(raw: &Raw) -> Result<Vec<&Raw>, Error> {
+    match map(raw, "a filter node")? {
+        [(key, value)] if key == b"and" => Ok(list(value, "'and'")?
+            .iter()
+            .map(conjuncts)
+            .collect::<Result<Vec<_>, _>>()?
+            .into_iter()
+            .flatten()
+            .collect()),
+        _ => Ok(vec![raw]),
+    }
+}
+
+/// The matcher of `intervals` for the arrow array arrow-rs reads `column` as: the file's arrow schema can turn an INT32
+/// DATE into Date64 milliseconds, a plain INT32/INT64 into a timestamp or a Date64, values unchanged.
+fn bounds(
+    column: &ColumnDescriptor,
+    path: &[String],
+    intervals: &[Interval<Scalar>],
+    data_type: &DataType,
+) -> Result<Matcher, Error> {
+    let malformed_bounds = || malformed(format!("bounds of \"{}\" are not {data_type} values", path.join(".")));
+    let signed = |factor: i64| {
+        typed(intervals, |scalar| match scalar {
+            Scalar::Int(value) => value.checked_mul(factor),
+            _ => None,
+        })
+        .ok_or_else(malformed_bounds)
+    };
+    let unsigned = |mask: u64| {
+        typed(intervals, |scalar| match scalar {
+            Scalar::Int(value) => Some(*value as u64 & mask),
+            _ => None,
+        })
+        .ok_or_else(malformed_bounds)
+    };
+    let floats = || {
+        typed(intervals, |scalar| match scalar {
+            Scalar::Float(value) => Some(*value),
+            Scalar::Int(value) => Some(*value as f64),
+            _ => None,
+        })
+        .ok_or_else(malformed_bounds)
+    };
+    let stored_unit = timestamp_unit(column.logical_type_ref(), column.converted_type());
+
+    Ok(match data_type {
+        DataType::Int8 => primitive::<Int8Type, _>(signed(1)?),
+        DataType::Int16 => primitive::<Int16Type, _>(signed(1)?),
+        DataType::Int32 => primitive::<Int32Type, _>(signed(1)?),
+        DataType::Int64 => primitive::<Int64Type, _>(signed(1)?),
+        DataType::Date32 => primitive::<Date32Type, _>(signed(1)?),
+        DataType::Date64 if column.physical_type() == Type::INT64 => primitive::<Date64Type, _>(signed(1)?),
+        DataType::Date64 => primitive::<Date64Type, _>(signed(86_400_000)?),
+        DataType::Time32(TimeUnit::Second) => primitive::<Time32SecondType, _>(signed(1)?),
+        DataType::Time32(_) => primitive::<Time32MillisecondType, _>(signed(1)?),
+        DataType::Time64(TimeUnit::Microsecond) => primitive::<Time64MicrosecondType, _>(signed(1)?),
+        DataType::Time64(_) => primitive::<Time64NanosecondType, _>(signed(1)?),
+        DataType::Timestamp(unit, _) if stored_unit.is_none_or(|stored| stored == *unit) => match unit {
+            TimeUnit::Second => primitive::<TimestampSecondType, _>(signed(1)?),
+            TimeUnit::Millisecond => primitive::<TimestampMillisecondType, _>(signed(1)?),
+            TimeUnit::Microsecond => primitive::<TimestampMicrosecondType, _>(signed(1)?),
+            TimeUnit::Nanosecond => primitive::<TimestampNanosecondType, _>(signed(1)?),
+        },
+        DataType::UInt8 => primitive::<UInt8Type, _>(unsigned(0xFFFF_FFFF)?),
+        DataType::UInt16 => primitive::<UInt16Type, _>(unsigned(0xFFFF_FFFF)?),
+        DataType::UInt32 => primitive::<UInt32Type, _>(unsigned(0xFFFF_FFFF)?),
+        DataType::UInt64 => primitive::<UInt64Type, _>(unsigned(u64::MAX)?),
+        DataType::Float32 => primitive::<Float32Type, _>(floats()?),
+        DataType::Float64 => primitive::<Float64Type, _>(floats()?),
+        DataType::Boolean => {
+            let intervals = typed(intervals, |scalar| match scalar {
+                Scalar::Bool(value) => Some(*value),
+                _ => None,
+            })
+            .ok_or_else(malformed_bounds)?;
+
+            Box::new(move |array: &ArrayRef| {
+                let values = array.as_boolean().values();
+
+                ordered(values.len(), |row| values.value(row), &intervals)
+            })
+        }
+        DataType::Decimal128(_, scale) if i32::from(*scale) == column.type_scale() => primitive::<Decimal128Type, _>(
+            typed(intervals, |scalar| match scalar {
+                Scalar::Int(value) => Some(i128::from(*value)),
+                Scalar::Bytes(bytes) => be_i128(bytes),
+                _ => None,
+            })
+            .ok_or_else(malformed_bounds)?,
+        ),
+        DataType::Decimal256(_, scale) if i32::from(*scale) == column.type_scale() => primitive::<Decimal256Type, _>(
+            typed(intervals, |scalar| match scalar {
+                Scalar::Int(value) => Some(i256::from_i128(i128::from(*value))),
+                Scalar::Bytes(bytes) => be_i256(bytes),
+                _ => None,
+            })
+            .ok_or_else(malformed_bounds)?,
+        ),
+        other => {
+            let byte_array = ByteArray::of(other).ok_or_else(|| unsupported(path, other))?;
+            let intervals = typed(intervals, |scalar| match scalar {
+                Scalar::Bytes(bytes) => Some(bytes.clone()),
+                _ => None,
+            })
+            .ok_or_else(malformed_bounds)?;
+
+            by_bytes(byte_array, move |value| {
+                holds(&intervals, |bound| Some(value.cmp(bound.as_slice())))
+            })
+        }
+    })
+}
+
+/// The arrow types whose rows are bytes.
+#[derive(Clone, Copy)]
+enum ByteArray {
+    Utf8,
+    LargeUtf8,
+    Utf8View,
+    Binary,
+    LargeBinary,
+    BinaryView,
+    FixedSizeBinary,
+}
+
+impl ByteArray {
+    fn of(data_type: &DataType) -> Option<Self> {
+        Some(match data_type {
+            DataType::Utf8 => Self::Utf8,
+            DataType::LargeUtf8 => Self::LargeUtf8,
+            DataType::Utf8View => Self::Utf8View,
+            DataType::Binary => Self::Binary,
+            DataType::LargeBinary => Self::LargeBinary,
+            DataType::BinaryView => Self::BinaryView,
+            DataType::FixedSizeBinary(_) => Self::FixedSizeBinary,
+            _ => return None,
+        })
+    }
+}
+
+/// A matcher testing each row's bytes.
+fn by_bytes(byte_array: ByteArray, test: impl Fn(&[u8]) -> bool + Send + 'static) -> Matcher {
+    macro_rules! rows {
+        ($cast:ident $(::<$offset:ty>)?) => {
+            Box::new(move |array: &ArrayRef| {
+                let array = array.$cast$(::<$offset>)?();
+
+                BooleanBuffer::collect_bool(array.len(), |row| {
+                    let value: &[u8] = array.value(row).as_ref();
+
+                    test(value)
+                })
+            })
+        };
+    }
+
+    match byte_array {
+        ByteArray::Utf8 => rows!(as_string::<i32>),
+        ByteArray::LargeUtf8 => rows!(as_string::<i64>),
+        ByteArray::Utf8View => rows!(as_string_view),
+        ByteArray::Binary => rows!(as_binary::<i32>),
+        ByteArray::LargeBinary => rows!(as_binary::<i64>),
+        ByteArray::BinaryView => rows!(as_binary_view),
+        ByteArray::FixedSizeBinary => rows!(as_fixed_size_binary),
+    }
+}
+
+impl<T> Interval<T> {
+    /// `order(bound)` orders the value against a bound; `None` (NaN) is in no bounded interval.
+    fn contains(&self, order: impl Fn(&T) -> Option<Ordering>) -> bool {
+        let lower = self.lower.as_ref().is_none_or(|bound| match order(bound) {
+            Some(Ordering::Greater) => true,
+            Some(Ordering::Equal) => self.lower_inclusive,
+            _ => false,
+        });
+        let upper = self.upper.as_ref().is_none_or(|bound| match order(bound) {
+            Some(Ordering::Less) => true,
+            Some(Ordering::Equal) => self.upper_inclusive,
+            _ => false,
+        });
+
+        lower && upper
+    }
+}
+
+/// Whether the value lies in the sorted, disjoint `intervals`: only the last one starting at or below it can hold it.
+fn holds<T>(intervals: &[Interval<T>], order: impl Fn(&T) -> Option<Ordering>) -> bool {
+    let candidate = intervals.partition_point(|interval| {
+        interval
+            .lower
+            .as_ref()
+            .is_none_or(|bound| matches!(order(bound), Some(Ordering::Greater | Ordering::Equal)))
+    });
+
+    candidate > 0 && intervals[candidate - 1].contains(order)
+}
+
+/// The values of an `A` array, widened to the bounds' type.
+fn primitive<A, T>(intervals: Vec<Interval<T>>) -> Matcher
+where
+    A: ArrowPrimitiveType,
+    T: PartialOrd + From<A::Native> + Send + 'static,
+{
+    Box::new(move |array: &ArrayRef| {
+        let values = array.as_primitive::<A>().values();
+
+        ordered(values.len(), |row| T::from(values[row]), &intervals)
+    })
+}
+
+/// Floats compare as IEEE 754 through `partial_cmp`: NaN orders with nothing, itself included, so it is in no interval,
+/// not even an unbounded one, and -0.0 == +0.0.
+fn ordered<T: PartialOrd>(rows: usize, value: impl Fn(usize) -> T, intervals: &[Interval<T>]) -> BooleanBuffer {
+    BooleanBuffer::collect_bool(rows, |row| {
+        let value = value(row);
+
+        value.partial_cmp(&value).is_some() && holds(intervals, |bound| value.partial_cmp(bound))
+    })
+}
+
+/// The leaf at `path` in a predicate batch, and its rows that are not null, a struct above it included.
+fn column(batch: &RecordBatch, path: &[String]) -> Result<(ArrayRef, BooleanBuffer), ArrowError> {
+    let missing = || ArrowError::SchemaError(format!("The row filter batch has no leaf \"{}\"", path.join(".")));
+    let (array, nulls) =
+        struct_child(batch.column_by_name(&path[0]).ok_or_else(missing)?, &path[1..]).map_err(|_| missing())?;
+    let valid = nulls.map_or_else(|| BooleanBuffer::new_set(array.len()), |nulls| nulls.into_inner());
+
+    Ok((array, valid))
+}
+
+/// The parquet leaf at `path`, added to `leaves` once.
+fn leaf(descr: &SchemaDescriptor, path: &[String], leaves: &mut Vec<usize>) -> Result<usize, Error> {
+    let leaf = (0..descr.num_columns())
+        .find(|leaf| descr.column(*leaf).path().parts() == path)
+        .ok_or_else(|| not_a_leaf(path))?;
+
+    if !leaves.contains(&leaf) {
+        leaves.push(leaf);
+    }
+
+    Ok(leaf)
+}
+
+fn not_a_leaf(path: &[String]) -> Error {
+    Error::Plan(format!(
+        "Row filter column \"{}\" is not a leaf of the file",
+        path.join(".")
+    ))
+}
+
+/// The arrow type the leaf at `path` is read as.
+fn data_type(schema: &Schema, path: &[String]) -> Result<DataType, Error> {
+    Ok(struct_field(schema, path)
+        .map_err(|_| not_a_leaf(path))?
+        .0
+        .data_type()
+        .clone())
+}
+
+fn timestamp_unit(logical: Option<&LogicalType>, converted: ConvertedType) -> Option<TimeUnit> {
+    match (logical, converted) {
+        (Some(LogicalType::Timestamp(timestamp)), _) => Some(match timestamp.unit {
+            parquet::basic::TimeUnit::MILLIS => TimeUnit::Millisecond,
+            parquet::basic::TimeUnit::MICROS => TimeUnit::Microsecond,
+            parquet::basic::TimeUnit::NANOS => TimeUnit::Nanosecond,
+        }),
+        (_, ConvertedType::TIMESTAMP_MILLIS) => Some(TimeUnit::Millisecond),
+        (_, ConvertedType::TIMESTAMP_MICROS) => Some(TimeUnit::Microsecond),
+        _ => None,
+    }
+}
+
+/// Every bound converted; `None` when one has another kind.
+fn typed<T>(intervals: &[Interval<Scalar>], convert: impl Fn(&Scalar) -> Option<T>) -> Option<Vec<Interval<T>>> {
+    intervals
+        .iter()
+        .map(|interval| {
+            Some(Interval {
+                lower: match &interval.lower {
+                    Some(bound) => Some(convert(bound)?),
+                    None => None,
+                },
+                lower_inclusive: interval.lower_inclusive,
+                upper: match &interval.upper {
+                    Some(bound) => Some(convert(bound)?),
+                    None => None,
+                },
+                upper_inclusive: interval.upper_inclusive,
+            })
+        })
+        .collect()
+}
+
+/// Big-endian two's complement of any width, `None` when it does not fit.
+fn be_i128(bytes: &[u8]) -> Option<i128> {
+    sign_extended::<16>(bytes).map(i128::from_be_bytes)
+}
+
+fn be_i256(bytes: &[u8]) -> Option<i256> {
+    sign_extended::<32>(bytes).map(i256::from_be_bytes)
+}
+
+fn sign_extended<const N: usize>(bytes: &[u8]) -> Option<[u8; N]> {
+    let extension = if bytes.first().is_some_and(|byte| *byte >= 0x80) {
+        0xFF
+    } else {
+        0x00
+    };
+    let mut bytes = bytes;
+
+    while bytes.len() > N {
+        let (first, rest) = bytes.split_first()?;
+
+        // dropping a sign-extension byte keeps the value only when the next byte carries the same sign
+        if *first != extension || (rest[0] >= 0x80) != (extension == 0xFF) {
+            return None;
+        }
+
+        bytes = rest;
+    }
+
+    let mut extended = [extension; N];
+    extended[N - bytes.len()..].copy_from_slice(bytes);
+
+    Some(extended)
+}
+
+fn unsupported(path: &[String], data_type: &DataType) -> Error {
+    Error::Unsupported {
+        column: path.join("."),
+        parquet: format!("{data_type} in a row filter"),
+    }
+}
+
+fn malformed(message: String) -> Error {
+    Error::Plan(format!("arrow received a malformed row filter: {message}"))
+}
+
+fn map<'a>(raw: &'a Raw, what: &str) -> Result<&'a [(Vec<u8>, Raw)], Error> {
+    match raw {
+        Raw::Map(entries) => Ok(entries),
+        other => Err(malformed(format!(
+            "{what} must be an array with string keys, got {other:?}"
+        ))),
+    }
+}
+
+fn list<'a>(raw: &'a Raw, what: &str) -> Result<&'a [Raw], Error> {
+    match raw {
+        Raw::List(entries) => Ok(entries),
+        other => Err(malformed(format!("{what} must be a list, got {other:?}"))),
+    }
+}
+
+fn field<'a>(entries: &'a [(Vec<u8>, Raw)], key: &[u8]) -> Result<&'a Raw, Error> {
+    entries
+        .iter()
+        .find(|(name, _)| name == key)
+        .map(|(_, value)| value)
+        .ok_or_else(|| malformed(format!("missing key \"{}\"", String::from_utf8_lossy(key))))
+}
+
+fn path(raw: &Raw) -> Result<Vec<String>, Error> {
+    let segments = list(raw, "a path")?
+        .iter()
+        .map(|segment| match segment {
+            Raw::Bytes(segment) => {
+                String::from_utf8(segment.clone()).map_err(|_| malformed("a path segment must be UTF-8".to_string()))
+            }
+            other => Err(malformed(format!("a path segment must be a string, got {other:?}"))),
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    if segments.is_empty() {
+        return Err(malformed("a path must not be empty".to_string()));
+    }
+
+    Ok(segments)
+}
+
+fn interval(raw: &Raw) -> Result<Interval<Scalar>, Error> {
+    let parts = list(raw, "an interval")?;
+    let [lower, lower_inclusive, upper, upper_inclusive] = parts else {
+        return Err(malformed(format!("an interval has 4 parts, got {}", parts.len())));
+    };
+    let inclusive = |raw: &Raw| match raw {
+        Raw::Bool(inclusive) => Ok(*inclusive),
+        other => Err(malformed(format!(
+            "an interval inclusiveness must be a bool, got {other:?}"
+        ))),
+    };
+
+    Ok(Interval {
+        lower: scalar(lower)?,
+        lower_inclusive: inclusive(lower_inclusive)?,
+        upper: scalar(upper)?,
+        upper_inclusive: inclusive(upper_inclusive)?,
+    })
+}
+
+fn scalar(raw: &Raw) -> Result<Option<Scalar>, Error> {
+    Ok(match raw {
+        Raw::Null => None,
+        Raw::Bool(value) => Some(Scalar::Bool(*value)),
+        Raw::Int(value) => Some(Scalar::Int(*value)),
+        Raw::Float(value) if value.is_nan() => return Err(malformed("a bound must not be NaN".to_string())),
+        Raw::Float(value) => Some(Scalar::Float(*value)),
+        Raw::Bytes(value) => Some(Scalar::Bytes(value.clone())),
+        other => return Err(malformed(format!("a bound must be a scalar, got {other:?}"))),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::{
+        Array, ArrayRef, BooleanArray, Date32Array, Date64Array, Decimal128Array, FixedSizeBinaryArray, Float64Array,
+        Int64Array, RecordBatch, StringArray, StructArray, TimestampSecondArray, UInt64Array,
+    };
+    use arrow_array::{Decimal256Array, Float32Array, Time32MillisecondArray, UInt32Array};
+    use arrow_buffer::i256;
+    use arrow_buffer::NullBuffer;
+    use arrow_schema::{DataType, Field, Fields, TimeUnit};
+    use parquet::arrow::arrow_reader::ArrowPredicate;
+    use parquet::arrow::parquet_to_arrow_schema;
+    use parquet::schema::parser::parse_message_type;
+    use parquet::schema::types::SchemaDescriptor;
+
+    use super::{Interval, PlanPredicate, Raw, Scalar};
+    use crate::parquet::error::Error;
+
+    const SCHEMA: &str = "message schema {
+        optional int64 i;
+        optional double f;
+        optional binary s (STRING);
+        optional int32 day (DATE);
+        optional fixed_len_byte_array(2) d (DECIMAL(4, 2));
+        optional int64 u (INTEGER(64, false));
+        optional fixed_len_byte_array(16) id (UUID);
+        optional group address { optional binary city (STRING); }
+        optional group tags (LIST) { repeated group list { optional binary element (STRING); } }
+    }";
+
+    fn descr() -> SchemaDescriptor {
+        SchemaDescriptor::new(Arc::new(parse_message_type(SCHEMA).unwrap()))
+    }
+
+    fn rows(filter: &Raw, column: &str, array: ArrayRef) -> Vec<bool> {
+        let descr = descr();
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+        let field = schema.field_with_name(column).unwrap().clone();
+
+        kept(filter, &arrow_schema::Schema::new(vec![field]), &descr, array)
+    }
+
+    /// The rows every conjunct's predicate keeps.
+    fn kept(filter: &Raw, schema: &arrow_schema::Schema, descr: &SchemaDescriptor, array: ArrayRef) -> Vec<bool> {
+        let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![array]).unwrap();
+        let mut kept = vec![true; batch.num_rows()];
+
+        for mut predicate in PlanPredicate::conjuncts(filter, schema, descr).unwrap() {
+            let truth = predicate.evaluate(batch.clone()).unwrap();
+
+            assert_eq!(truth.null_count(), 0);
+
+            kept = kept
+                .iter()
+                .zip(truth.iter())
+                .map(|(kept, truth)| *kept && truth.unwrap())
+                .collect();
+        }
+
+        kept
+    }
+
+    fn node(entries: Vec<(&str, Raw)>) -> Raw {
+        map(entries)
+    }
+
+    fn path(path: &[&str]) -> Raw {
+        Raw::List(path.iter().map(|segment| bytes(segment)).collect())
+    }
+
+    fn bound(bound: Option<Scalar>) -> Raw {
+        match bound {
+            None => Raw::Null,
+            Some(Scalar::Int(value)) => Raw::Int(value),
+            Some(Scalar::Float(value)) => Raw::Float(value),
+            Some(Scalar::Bool(value)) => Raw::Bool(value),
+            Some(Scalar::Bytes(value)) => Raw::Bytes(value),
+        }
+    }
+
+    fn intervals_at(at: &[&str], intervals: Vec<Interval<Scalar>>) -> Raw {
+        node(vec![
+            ("leaf", bytes("intervals")),
+            ("path", path(at)),
+            (
+                "intervals",
+                Raw::List(
+                    intervals
+                        .into_iter()
+                        .map(|interval| {
+                            Raw::List(vec![
+                                bound(interval.lower),
+                                Raw::Bool(interval.lower_inclusive),
+                                bound(interval.upper),
+                                Raw::Bool(interval.upper_inclusive),
+                            ])
+                        })
+                        .collect(),
+                ),
+            ),
+        ])
+    }
+
+    fn intervals(column: &str, intervals: Vec<Interval<Scalar>>) -> Raw {
+        intervals_at(&[column], intervals)
+    }
+
+    fn is_null(at: &[&str]) -> Raw {
+        node(vec![("leaf", bytes("is_null")), ("path", path(at))])
+    }
+
+    fn starts_with(at: &[&str], prefix: &[u8]) -> Raw {
+        node(vec![
+            ("leaf", bytes("starts_with")),
+            ("path", path(at)),
+            ("prefix", Raw::Bytes(prefix.to_vec())),
+        ])
+    }
+
+    fn absent(is_null: bool) -> Raw {
+        node(vec![("leaf", bytes("absent")), ("is_null", Raw::Bool(is_null))])
+    }
+
+    fn and(nodes: Vec<Raw>) -> Raw {
+        node(vec![("and", Raw::List(nodes))])
+    }
+
+    fn or(nodes: Vec<Raw>) -> Raw {
+        node(vec![("or", Raw::List(nodes))])
+    }
+
+    fn below<T>(bound: T, inclusive: bool) -> Interval<T> {
+        Interval {
+            lower: None,
+            lower_inclusive: false,
+            upper: Some(bound),
+            upper_inclusive: inclusive,
+        }
+    }
+
+    fn point<T: Clone>(bound: T) -> Interval<T> {
+        Interval {
+            lower: Some(bound.clone()),
+            lower_inclusive: true,
+            upper: Some(bound),
+            upper_inclusive: true,
+        }
+    }
+
+    fn not(negated: Raw) -> Raw {
+        node(vec![("not", negated)])
+    }
+
+    fn ints() -> ArrayRef {
+        Arc::new(Int64Array::from(vec![None, Some(3), Some(7)]))
+    }
+
+    #[test]
+    fn a_null_stays_null_under_not_and_is_never_kept() {
+        let lt = intervals("i", vec![below(Scalar::Int(5), false)]);
+
+        assert_eq!(rows(&lt, "i", ints()), [false, true, false]);
+        assert_eq!(rows(&not(lt.clone()), "i", ints()), [false, false, true]);
+        assert_eq!(rows(&not(not(lt)), "i", ints()), [false, true, false]);
+    }
+
+    #[test]
+    fn and_and_or_follow_kleene_logic_and_swap_under_not() {
+        let lt = intervals("i", vec![below(Scalar::Int(5), false)]);
+        let null = is_null(&["i"]);
+
+        assert_eq!(
+            rows(&or(vec![lt.clone(), null.clone()]), "i", ints()),
+            [true, true, false]
+        );
+        assert_eq!(
+            rows(&not(and(vec![lt.clone(), not(null.clone())])), "i", ints()),
+            [true, false, true]
+        );
+        assert_eq!(rows(&not(or(vec![lt, null])), "i", ints()), [false, false, true]);
+        assert_eq!(rows(&and(vec![]), "i", ints()), [true, true, true]);
+        assert_eq!(rows(&not(and(vec![])), "i", ints()), [false, false, false]);
+        assert_eq!(rows(&or(vec![]), "i", ints()), [false, false, false]);
+    }
+
+    #[test]
+    fn nan_is_in_no_interval_so_every_negation_keeps_it() {
+        let floats: ArrayRef = Arc::new(Float64Array::from(vec![Some(f64::NAN), Some(3.0), Some(5.0), None]));
+        let lt = intervals("f", vec![below(Scalar::Float(5.0), false)]);
+        let unbounded = intervals(
+            "f",
+            vec![Interval {
+                lower: None,
+                lower_inclusive: false,
+                upper: None,
+                upper_inclusive: false,
+            }],
+        );
+
+        assert_eq!(rows(&lt, "f", Arc::clone(&floats)), [false, true, false, false]);
+        assert_eq!(rows(&not(lt), "f", Arc::clone(&floats)), [true, false, true, false]);
+        assert_eq!(
+            rows(
+                &not(intervals("f", vec![point(Scalar::Float(5.0))])),
+                "f",
+                Arc::clone(&floats)
+            ),
+            [true, true, false, false]
+        );
+        assert_eq!(rows(&unbounded, "f", floats), [false, true, true, false]);
+    }
+
+    #[test]
+    fn negative_zero_equals_positive_zero() {
+        let zeros: ArrayRef = Arc::new(Float64Array::from(vec![-0.0, 0.0]));
+
+        assert_eq!(
+            rows(
+                &intervals("f", vec![point(Scalar::Float(0.0))]),
+                "f",
+                Arc::clone(&zeros)
+            ),
+            [true, true]
+        );
+        assert_eq!(
+            rows(&intervals("f", vec![below(Scalar::Float(0.0), false)]), "f", zeros),
+            [false, false]
+        );
+    }
+
+    #[test]
+    fn a_decimal_bound_of_any_width_compares_with_the_unscaled_value() {
+        let decimals: ArrayRef = Arc::new(
+            Decimal128Array::from(vec![Some(1234), Some(1233), Some(-1234), None])
+                .with_precision_and_scale(4, 2)
+                .unwrap(),
+        );
+        let wide = Scalar::Bytes(vec![0, 0, 0, 0, 0, 0, 0x04, 0xD2]);
+
+        assert_eq!(
+            rows(&intervals("d", vec![point(wide.clone())]), "d", Arc::clone(&decimals)),
+            [true, false, false, false]
+        );
+        assert_eq!(
+            rows(&intervals("d", vec![below(wide, false)]), "d", Arc::clone(&decimals)),
+            [false, true, true, false]
+        );
+        assert_eq!(
+            rows(
+                &intervals("d", vec![below(Scalar::Bytes(vec![0xFF, 0x00]), true)]),
+                "d",
+                decimals
+            ),
+            [false, false, true, false]
+        );
+    }
+
+    #[test]
+    fn a_date_bound_is_its_day_number() {
+        let days: ArrayRef = Arc::new(Date32Array::from(vec![1, 2, 3]));
+
+        assert_eq!(
+            rows(&intervals("day", vec![point(Scalar::Int(2))]), "day", days),
+            [false, true, false]
+        );
+    }
+
+    #[test]
+    fn an_unsigned_64_bit_pattern_compares_unsigned() {
+        let big: ArrayRef = Arc::new(UInt64Array::from(vec![5, u64::MAX]));
+
+        assert_eq!(
+            rows(&intervals("u", vec![below(Scalar::Int(-1), false)]), "u", big),
+            [true, false]
+        );
+    }
+
+    #[test]
+    fn bytes_compare_unsigned_and_prefixes_match_raw_bytes() {
+        let strings: ArrayRef = Arc::new(StringArray::from(vec![Some("a"), Some("ź"), Some(""), None]));
+        let prefix = |prefix: &str| starts_with(&["s"], prefix.as_bytes());
+
+        assert_eq!(
+            rows(
+                &intervals("s", vec![below(Scalar::Bytes(b"z".to_vec()), false)]),
+                "s",
+                Arc::clone(&strings)
+            ),
+            [true, false, true, false]
+        );
+        assert_eq!(rows(&prefix(""), "s", Arc::clone(&strings)), [true, true, true, false]);
+        assert_eq!(
+            rows(&not(prefix("")), "s", Arc::clone(&strings)),
+            [false, false, false, false]
+        );
+        assert_eq!(
+            rows(&prefix("\u{c5}"), "s", Arc::clone(&strings)),
+            [false, false, false, false]
+        );
+        assert_eq!(
+            rows(&starts_with(&["s"], &[0xC5]), "s", strings),
+            [false, true, false, false]
+        );
+    }
+
+    #[test]
+    fn a_uuid_compares_its_sixteen_bytes() {
+        let ids: ArrayRef =
+            Arc::new(FixedSizeBinaryArray::try_from_iter(vec![[1u8; 16], [2u8; 16]].into_iter()).unwrap());
+
+        assert_eq!(
+            rows(&intervals("id", vec![point(Scalar::Bytes(vec![2; 16]))]), "id", ids),
+            [false, true]
+        );
+    }
+
+    #[test]
+    fn an_absent_column_is_null_in_every_row() {
+        assert_eq!(rows(&absent(false), "i", ints()), [false, false, false]);
+        assert_eq!(rows(&not(absent(false)), "i", ints()), [false, false, false]);
+        assert_eq!(rows(&absent(true), "i", ints()), [true, true, true]);
+        assert_eq!(rows(&not(absent(true)), "i", ints()), [false, false, false]);
+    }
+
+    #[test]
+    fn a_value_is_found_among_sorted_intervals() {
+        let values: ArrayRef = Arc::new(Int64Array::from(vec![1, 2, 5, 6, 8, 9]));
+        let above = Interval {
+            lower: Some(Scalar::Int(8)),
+            lower_inclusive: false,
+            upper: None,
+            upper_inclusive: false,
+        };
+
+        assert_eq!(
+            rows(
+                &intervals("i", vec![below(Scalar::Int(2), false), point(Scalar::Int(5)), above]),
+                "i",
+                values
+            ),
+            [true, false, true, false, false, true]
+        );
+    }
+
+    #[test]
+    fn each_root_conjunct_is_its_own_predicate_reading_its_own_leaves() {
+        let descr = descr();
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+        let null = |column: &str| is_null(&[column]);
+        let predicates = PlanPredicate::conjuncts(
+            &and(vec![null("s"), and(vec![null("i"), or(vec![null("f"), null("i")])])]),
+            &schema,
+            &descr,
+        )
+        .unwrap();
+
+        assert_eq!(
+            predicates.iter().map(PlanPredicate::leaves).collect::<Vec<_>>(),
+            [&[2][..], &[0], &[1, 0]]
+        );
+        assert!(PlanPredicate::conjuncts(&and(vec![]), &schema, &descr)
+            .unwrap()
+            .is_empty());
+    }
+
+    #[test]
+    fn every_primitive_kind_compares_in_its_own_type() {
+        let descr = SchemaDescriptor::new(Arc::new(
+            parse_message_type(
+                "message schema {
+                    optional int32 u32 (INTEGER(32, false));
+                    optional float f32;
+                    optional int32 t (TIME(MILLIS, true));
+                    optional fixed_len_byte_array(17) d (DECIMAL(40, 2));
+                }",
+            )
+            .unwrap(),
+        ));
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+        let single = |name: &str| arrow_schema::Schema::new(vec![schema.field_with_name(name).unwrap().clone()]);
+        let cases: Vec<(Raw, &str, ArrayRef, Vec<bool>)> = vec![
+            (
+                intervals("u32", vec![below(Scalar::Int(-1), false)]),
+                "u32",
+                Arc::new(UInt32Array::from(vec![5, u32::MAX])),
+                vec![true, false],
+            ),
+            (
+                not(intervals("f32", vec![below(Scalar::Float(5.0), false)])),
+                "f32",
+                Arc::new(Float32Array::from(vec![f32::NAN, 3.0, 5.0])),
+                vec![true, false, true],
+            ),
+            (
+                intervals("t", vec![point(Scalar::Int(2_000))]),
+                "t",
+                Arc::new(Time32MillisecondArray::from(vec![1_000, 2_000])),
+                vec![false, true],
+            ),
+            (
+                intervals("d", vec![below(Scalar::Bytes(vec![0x04, 0xD2]), false)]),
+                "d",
+                Arc::new(
+                    Decimal256Array::from(vec![i256::from_i128(1234), i256::from_i128(-1234)])
+                        .with_precision_and_scale(40, 2)
+                        .unwrap(),
+                ),
+                vec![false, true],
+            ),
+        ];
+
+        for (filter, column, array, expected) in cases {
+            assert_eq!(kept(&filter, &single(column), &descr, array), expected, "{column}");
+        }
+    }
+
+    #[test]
+    fn a_date64_hint_turns_day_bounds_into_milliseconds_and_a_timestamp_hint_keeps_plain_integers() {
+        let descr = SchemaDescriptor::new(Arc::new(
+            parse_message_type("message schema { optional int32 day (DATE); optional int64 seconds; }").unwrap(),
+        ));
+        let day = Field::new("day", DataType::Date64, true);
+        let seconds = Field::new("seconds", DataType::Timestamp(TimeUnit::Second, None), true);
+
+        assert_eq!(
+            kept(
+                &intervals("day", vec![point(Scalar::Int(2))]),
+                &arrow_schema::Schema::new(vec![day]),
+                &descr,
+                Arc::new(Date64Array::from(vec![86_400_000, 172_800_000, 172_800_001]))
+            ),
+            [false, true, false]
+        );
+        assert_eq!(
+            kept(
+                &intervals("seconds", vec![below(Scalar::Int(2), true)]),
+                &arrow_schema::Schema::new(vec![seconds]),
+                &descr,
+                Arc::new(TimestampSecondArray::from(vec![2, 3]))
+            ),
+            [true, false]
+        );
+    }
+
+    #[test]
+    fn a_struct_leaf_is_null_where_its_struct_is() {
+        let cities = Arc::new(StringArray::from(vec![Some("a"), Some("a")])) as ArrayRef;
+        let address: ArrayRef = Arc::new(StructArray::new(
+            Fields::from(vec![Field::new("city", DataType::Utf8, true)]),
+            vec![cities],
+            Some(NullBuffer::from(vec![true, false])),
+        ));
+        let city = intervals_at(&["address", "city"], vec![point(Scalar::Bytes(b"a".to_vec()))]);
+        let null = is_null(&["address", "city"]);
+
+        assert_eq!(rows(&city, "address", Arc::clone(&address)), [true, false]);
+        assert_eq!(rows(&not(city), "address", Arc::clone(&address)), [false, false]);
+        assert_eq!(rows(&null, "address", address), [false, true]);
+    }
+
+    #[test]
+    fn booleans_order_false_before_true() {
+        let flags: ArrayRef = Arc::new(BooleanArray::from(vec![false, true]));
+        let descr = SchemaDescriptor::new(Arc::new(
+            parse_message_type("message schema { optional boolean b; }").unwrap(),
+        ));
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+
+        assert_eq!(
+            kept(
+                &intervals("b", vec![below(Scalar::Bool(true), false)]),
+                &schema,
+                &descr,
+                flags
+            ),
+            [true, false]
+        );
+    }
+
+    #[test]
+    fn a_bound_of_another_kind_than_the_column_or_a_path_that_is_no_leaf_is_refused() {
+        let descr = descr();
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+        let refused = |filter: Raw| match PlanPredicate::conjuncts(&filter, &schema, &descr) {
+            Err(Error::Plan(message)) => message,
+            _ => panic!("the filter was not refused"),
+        };
+
+        assert_eq!(
+            refused(intervals("i", vec![point(Scalar::Bytes(b"1".to_vec()))])),
+            "arrow received a malformed row filter: bounds of \"i\" are not Int64 values"
+        );
+        assert_eq!(
+            refused(is_null(&["missing"])),
+            "Row filter column \"missing\" is not a leaf of the file"
+        );
+        assert_eq!(
+            refused(is_null(&["i", "deeper"])),
+            "Row filter column \"i.deeper\" is not a leaf of the file"
+        );
+        assert_eq!(
+            refused(is_null(&["tags", "list", "element"])),
+            "Row filter column \"tags.list.element\" is not a leaf of the file"
+        );
+    }
+
+    fn map(entries: Vec<(&str, Raw)>) -> Raw {
+        Raw::Map(
+            entries
+                .into_iter()
+                .map(|(key, value)| (key.as_bytes().to_vec(), value))
+                .collect(),
+        )
+    }
+
+    fn bytes(value: &str) -> Raw {
+        Raw::Bytes(value.as_bytes().to_vec())
+    }
+
+    #[test]
+    fn the_converter_shape_compiles_into_one_predicate_per_root_conjunct() {
+        let descr = descr();
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+        let predicates = PlanPredicate::conjuncts(
+            &and(vec![
+                not(absent(true)),
+                or(vec![intervals_at(
+                    &["address", "city"],
+                    vec![Interval {
+                        lower: Some(Scalar::Bytes(b"a".to_vec())),
+                        lower_inclusive: true,
+                        upper: None,
+                        upper_inclusive: false,
+                    }],
+                )]),
+                is_null(&["i"]),
+                starts_with(&["s"], b"p"),
+                and(vec![]),
+            ]),
+            &schema,
+            &descr,
+        )
+        .unwrap();
+
+        assert_eq!(
+            predicates.iter().map(PlanPredicate::leaves).collect::<Vec<_>>(),
+            [&[][..], &[7], &[0], &[2]]
+        );
+    }
+
+    #[test]
+    fn an_unknown_leaf_or_a_missing_key_is_refused() {
+        let descr = descr();
+        let schema = parquet_to_arrow_schema(&descr, None).unwrap();
+        let refused = |filter: Raw| match PlanPredicate::conjuncts(&filter, &schema, &descr) {
+            Err(Error::Plan(message)) => message.replace("arrow received a malformed row filter: ", ""),
+            _ => panic!("the filter was not refused"),
+        };
+
+        assert_eq!(refused(map(vec![("xor", Raw::List(vec![]))])), "missing key \"leaf\"");
+        assert!(refused(map(vec![("leaf", bytes("between"))])).starts_with("unknown leaf"));
+        assert_eq!(refused(map(vec![("leaf", bytes("is_null"))])), "missing key \"path\"");
+        assert_eq!(refused(map(vec![("leaf", bytes("absent"))])), "missing key \"is_null\"");
+        assert_eq!(
+            refused(map(vec![
+                ("leaf", bytes("intervals")),
+                ("path", Raw::List(vec![bytes("f")])),
+                (
+                    "intervals",
+                    Raw::List(vec![Raw::List(vec![
+                        Raw::Float(f64::NAN),
+                        Raw::Bool(true),
+                        Raw::Null,
+                        Raw::Bool(false)
+                    ])])
+                ),
+            ])),
+            "a bound must not be NaN"
+        );
+    }
+}
diff --git a/src/extension/arrow-ext/src/parquet/footer.rs b/src/extension/arrow-ext/src/parquet/footer.rs
index eab46a8ae6..d12275889b 100644
--- a/src/extension/arrow-ext/src/parquet/footer.rs
+++ b/src/extension/arrow-ext/src/parquet/footer.rs
@@ -7,6 +7,7 @@ use bytes::{Bytes, BytesMut};
 use parquet::file::metadata::{ParquetMetaData, ParquetMetaDataReader};
 use parquet::file::reader::ChunkReader;
 
+use crate::parquet::chunks::refuse_encrypted;
 use crate::parquet::error::Error;
 
 /// What the first read takes from the end of the file: the whole footer of every file it is shorter than.
@@ -14,6 +15,9 @@ const TAIL: u64 = 64 * 1024;
 
 const MAGIC: &[u8; 4] = b"PAR1";
 
+/// The magic of a file whose footer is encrypted (Parquet modular encryption).
+const ENCRYPTED_MAGIC: &[u8; 4] = b"PARE";
+
 pub struct Footer {
     /// The thrift `FileMetaData`.
     bytes: Bytes,
@@ -35,6 +39,10 @@ impl Footer {
         let tail = source.get_bytes(size - read, read as usize)?;
         let trailer = &tail[tail.len() - 8..];
 
+        if &trailer[4..] == ENCRYPTED_MAGIC {
+            return Err(Error::Encrypted);
+        }
+
         if &trailer[4..] != MAGIC {
             return Err(corrupt("Invalid Parquet file. Corrupt footer".to_string()));
         }
@@ -58,6 +66,7 @@ impl Footer {
             bytes.freeze()
         };
         let meta = ParquetMetaDataReader::decode_metadata(&bytes)?;
+        refuse_encrypted(&bytes)?;
 
         Ok(Self {
             bytes,
@@ -176,4 +185,16 @@ mod tests {
             Err(Error::NotParquet(_))
         ));
     }
+
+    #[test]
+    fn a_file_with_an_encrypted_footer_is_refused() {
+        let mut data = file(10);
+        let end = data.len();
+        data[end - 1] = b'E';
+
+        assert!(matches!(
+            Footer::read(&Source(Arc::new(Counting::new(data)))),
+            Err(Error::Encrypted)
+        ));
+    }
 }
diff --git a/src/extension/arrow-ext/src/parquet/lib_calls.rs b/src/extension/arrow-ext/src/parquet/lib_calls.rs
index 1cd3227ecd..da1034f92b 100644
--- a/src/extension/arrow-ext/src/parquet/lib_calls.rs
+++ b/src/extension/arrow-ext/src/parquet/lib_calls.rs
@@ -11,6 +11,8 @@ pub const SCHEMA_FROM_THRIFT: &str = "Flow\\Parquet\\ParquetFile\\Schema::fromTh
 pub const SCHEMA_TO_EXTENSION: &str = "Flow\\Parquet\\Engine\\Arrow\\SchemaConverter::toExtension";
 pub const OPTIONS_TO_EXTENSION: &str = "Flow\\Parquet\\Engine\\Arrow\\OptionsConverter::toExtension";
 pub const OPTIONS_TO_ENGINE: &str = "Flow\\Parquet\\Engine\\Arrow\\OptionsConverter::toEngine";
+pub const READ_PLAN_TO_EXTENSION: &str = "Flow\\Parquet\\Engine\\Arrow\\ReadPlanConverter::toExtension";
+pub const ROW_GROUP_CHUNKS_FROM_THRIFT: &str = "Flow\\Parquet\\Engine\\Arrow\\RustRowGroupChunks::fromThrift";
 
 /// `Class::method(...$args)`; an exception the method throws surfaces as itself.
 pub fn call_static(name: &str, args: &mut [Zval]) -> PhpResult<Zval> {
diff --git a/src/extension/arrow-ext/src/parquet/library.rs b/src/extension/arrow-ext/src/parquet/library.rs
index b89418385f..facb8caa35 100644
--- a/src/extension/arrow-ext/src/parquet/library.rs
+++ b/src/extension/arrow-ext/src/parquet/library.rs
@@ -1,8 +1,9 @@
-//! `Flow\Parquet\Engine\{RustParquetFileReader, RustParquetFileWriter}` and `Flow\Arrow\Parquet\RustColumnsReader`: the
+//! `Flow\Parquet\Engine\{RustParquetFileReader, RustParquetFooter, RustParquetFileWriter}` and `Flow\Arrow\Parquet\RustColumnsReader`: the
 //! `flow-php/parquet` lib's values over the core -
 //! one footer read per file, columns as lists of the values `PhpParquetEngine` returns, rows written as it accepts
 //! them, and struct batches written as another extension exports them.
 
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use arrow_array::{new_null_array, Array, ArrayRef};
@@ -10,25 +11,29 @@ use ext_php_rs::convert::IntoZval;
 use ext_php_rs::error::Result as ZvalResult;
 use ext_php_rs::flags::{ClassFlags, DataType};
 use ext_php_rs::prelude::*;
-use ext_php_rs::types::{ZendHashTable, Zval};
+use ext_php_rs::types::{ZendClassObject, ZendHashTable, Zval};
 use ext_php_rs::zend::ce;
 use parquet::basic::Type as PhysicalType;
 use parquet::file::metadata::ParquetMetaData;
-use parquet::file::reader::Length;
 
-use crate::interfaces::{parquet_file_reader_ce, parquet_file_writer_ce};
+use crate::interfaces::{footer_ce, parquet_file_reader_ce, parquet_file_writer_ce};
 use crate::parquet::batch;
 use crate::parquet::cells::{Checked, Classes, ReadCell, Refusal, Scalar, Times, Validated, WriteColumn};
+use crate::parquet::chunks::chunk_spans;
 use crate::parquet::error::Error;
+use crate::parquet::filter::Raw;
 use crate::parquet::footer::Footer;
-use crate::parquet::lib_calls::{call_static, METADATA_FROM_THRIFT, SCHEMA_FROM_THRIFT};
+use crate::parquet::lib_calls::{
+    call_static, METADATA_FROM_THRIFT, READ_PLAN_TO_EXTENSION, ROW_GROUP_CHUNKS_FROM_THRIFT, SCHEMA_FROM_THRIFT,
+};
 use crate::parquet::options;
 use crate::parquet::read::{ParquetReader, ReadPlan};
 use crate::parquet::sink::PhpSink;
 use crate::parquet::source::{PhpSource, PhpStream};
 use crate::parquet::write::ParquetWriter;
 use crate::php::{
-    call_method, expect_object, for_each_value, ht_for_each, ht_get, ht_insert, read_property, IterableArg,
+    call_method, expect_object, for_each_value, ht_for_each, ht_get, ht_insert, ht_insert_long, read_property,
+    zval_array, zval_long, zval_str, IterableArg,
 };
 use crate::render::{exception, parquet_exception, Side};
 use crate::thrift;
@@ -71,17 +76,116 @@ impl IntoZval for SchemaObject {
     }
 }
 
-pub fn rows(value: Option<i64>, name: &str) -> PhpResult<Option<u64>> {
-    value
-        .map(|value| {
-            u64::try_from(value).map_err(|_| {
-                exception(
-                    INVALID_ARGUMENT,
-                    format!("arrow Parquet {name} must be greater or equal to 0"),
-                )
-            })
-        })
-        .transpose()
+/// `ParquetFileReader::rowGroupChunks()`'s return, a `Flow\Parquet\Engine\Arrow\RustRowGroupChunks` typed as the
+/// interface: a covariant userland return type cannot be checked when the class registers.
+pub struct RowGroupChunksObject(Zval);
+
+impl IntoZval for RowGroupChunksObject {
+    const TYPE: DataType = DataType::object("Flow\\Parquet\\ParquetFile\\RowGroupChunks");
+    const NULLABLE: bool = false;
+
+    fn set_zval(self, zv: &mut Zval, _persistent: bool) -> ZvalResult<()> {
+        *zv = self.0;
+
+        Ok(())
+    }
+}
+
+/// `$plan` (a `Flow\Parquet\Reader\ReadPlan`) through `ReadPlanConverter::toExtension()`, checked against `meta`.
+pub fn read_plan(meta: &ParquetMetaData, plan: &Zval, stream: &PhpStream) -> PhpResult<ReadPlan> {
+    let converted = call_static(READ_PLAN_TO_EXTENSION, &mut [plan.shallow_clone()])?;
+
+    converted_plan(meta, &converted).map_err(|error| parquet_exception(error, stream, Side::Read))
+}
+
+fn converted_plan(meta: &ParquetMetaData, converted: &Zval) -> Result<ReadPlan, Error> {
+    let malformed = |what: &str| Error::Plan(format!("arrow received a malformed read plan: {what}"));
+    let converted = converted.array().ok_or_else(|| malformed("not an array"))?;
+    let selectors = ht_get(converted, b"selectors")
+        .and_then(Zval::array)
+        .ok_or_else(|| malformed("no 'selectors' list"))?;
+    let mut planned = Vec::with_capacity(selectors.len());
+
+    ht_for_each(selectors, |_, _, selector| {
+        let selector = selector
+            .array()
+            .ok_or_else(|| malformed("a selector is not an array"))?;
+        let count = selector
+            .get_index(0)
+            .and_then(Zval::long)
+            .and_then(|count| usize::try_from(count).ok())
+            .ok_or_else(|| malformed("a selector's row count is not an int of 0 or more"))?;
+        let skip = selector
+            .get_index(1)
+            .and_then(Zval::bool)
+            .ok_or_else(|| malformed("a selector's skip is not a bool"))?;
+
+        planned.push((count, skip));
+
+        Ok::<(), Error>(())
+    })?;
+
+    let limit = match ht_get(converted, b"limit") {
+        Some(limit) if limit.is_null() => None,
+        Some(limit) => Some(
+            limit
+                .long()
+                .and_then(|limit| usize::try_from(limit).ok())
+                .ok_or_else(|| malformed("'limit' is not an int of 0 or more"))?,
+        ),
+        None => return Err(malformed("no 'limit'")),
+    };
+    let filter = ht_get(converted, b"filter").map(raw).transpose()?;
+
+    ReadPlan::from_selection(meta, planned, filter, limit)
+}
+
+/// A converter array as data: a map keyed by its keys' bytes when a key is a string, else a list of its values.
+fn raw(value: &Zval) -> Result<Raw, Error> {
+    if value.is_null() {
+        return Ok(Raw::Null);
+    }
+
+    if let Some(value) = value.bool() {
+        return Ok(Raw::Bool(value));
+    }
+
+    if let Some(value) = value.long() {
+        return Ok(Raw::Int(value));
+    }
+
+    if let Some(value) = value.double() {
+        return Ok(Raw::Float(value));
+    }
+
+    if let Some(value) = value.zend_str() {
+        return Ok(Raw::Bytes(value.as_bytes().to_vec()));
+    }
+
+    let Some(table) = value.array() else {
+        return Err(Error::Plan(format!(
+            "arrow received a malformed row filter: a {} is no row filter value",
+            value.get_type()
+        )));
+    };
+    let mut entries = Vec::new();
+    let mut keyed = false;
+
+    ht_for_each(table, |key, index, value| {
+        keyed |= key.is_some();
+        entries.push((
+            key.map_or_else(|| index.to_string().into_bytes(), |key| key.as_bytes().to_vec()),
+            raw(value)?,
+        ));
+
+        Ok::<(), Error>(())
+    })?;
+
+    Ok(if keyed {
+        Raw::Map(entries)
+    } else {
+        Raw::List(entries.into_iter().map(|(_, value)| value).collect())
+    })
 }
 
 pub fn batch_size(value: i64) -> PhpResult<usize> {
@@ -93,6 +197,21 @@ pub fn batch_size(value: i64) -> PhpResult<usize> {
     })
 }
 
+/// `ParquetFileReader::footer()`'s return, typed `Flow\Parquet\Engine\RustParquetFooter`: the class registers before
+/// the reader, so the covariant return type is checked.
+pub struct FooterObject(Zval);
+
+impl IntoZval for FooterObject {
+    const TYPE: DataType = DataType::object("Flow\\Parquet\\Engine\\RustParquetFooter");
+    const NULLABLE: bool = false;
+
+    fn set_zval(self, zv: &mut Zval, _persistent: bool) -> ZvalResult<()> {
+        *zv = self.0;
+
+        Ok(())
+    }
+}
+
 #[php_class]
 #[php(
     name = "Flow\\Parquet\\Engine\\RustParquetFileReader",
@@ -101,12 +220,11 @@ pub fn batch_size(value: i64) -> PhpResult<usize> {
 )]
 pub struct RustParquetFileReader {
     stream: Arc<PhpStream>,
-    source: PhpSource,
-    footer: Footer,
+    footer: Arc<Footer>,
+    /// Each leaf's dotted path and its index among the schema's leaves.
+    leaves: Arc<HashMap<String, usize>>,
     int96_as_datetime: bool,
-    metadata: Option<Zval>,
-    schema: Option<Zval>,
-    thrift: Option<Zval>,
+    footer_object: Option<Zval>,
     closed: bool,
 }
 
@@ -119,16 +237,11 @@ impl RustParquetFileReader {
         Ok(())
     }
 
-    /// The file's stream, size and footer, for a reader of it: the lib's `RustColumnsReader` or a `RustBatchReader`.
-    pub fn read(&self) -> PhpResult<(&Arc<PhpStream>, u64, &Arc<ParquetMetaData>)> {
+    /// The file's stream and footer, for a reader of it: the lib's `RustColumnsReader` or a `RustBatchReader`.
+    pub fn read(&self) -> PhpResult<(&Arc<PhpStream>, &Arc<ParquetMetaData>)> {
         self.open()?;
 
-        Ok((&self.stream, self.source.len(), self.footer.meta()))
-    }
-
-    /// `FileMetaData::$schema`: the list of `SchemaElement`s.
-    fn elements(&self) -> PhpResult<Zval> {
-        thrift::decode(self.footer.bytes(), FILE_META_DATA, Some(SCHEMA))
+        Ok((&self.stream, self.footer.meta()))
     }
 
     /// Without `int96AsDatetime`, a requested column (a leaf path, or the path of its parent) holding INT96.
@@ -137,21 +250,18 @@ impl RustParquetFileReader {
             return Ok(());
         }
 
-        let leaves = self
-            .footer
-            .meta()
-            .file_metadata()
-            .schema_descr()
-            .columns()
+        let descr = self.footer.meta().file_metadata().schema_descr();
+        let int96 = self
+            .leaves
             .iter()
-            .filter(|leaf| leaf.physical_type() == PhysicalType::INT96)
-            .map(|leaf| leaf.path().string())
+            .filter(|(_, leaf)| descr.column(**leaf).physical_type() == PhysicalType::INT96)
+            .map(|(path, _)| path)
             .collect::<Vec<_>>();
 
         for column in columns.values().filter_map(Zval::str) {
-            if leaves
+            if int96
                 .iter()
-                .any(|leaf| leaf == column || leaf.starts_with(&format!("{column}.")))
+                .any(|leaf| *leaf == column || leaf.starts_with(&format!("{column}.")))
             {
                 return Err(exception(
                     INVALID_ARGUMENT,
@@ -177,26 +287,31 @@ impl RustParquetFileReader {
         let refused = |error| parquet_exception(error, &stream, Side::Read);
         let source = PhpSource::new(Arc::clone(&stream)).map_err(refused)?;
         let footer = Footer::read(&source).map_err(refused)?;
+        let leaves = footer
+            .meta()
+            .file_metadata()
+            .schema_descr()
+            .columns()
+            .iter()
+            .enumerate()
+            .map(|(index, leaf)| (leaf.path().string(), index))
+            .collect();
 
         Ok(Self {
             stream,
-            source,
-            footer,
+            footer: Arc::new(footer),
+            leaves: Arc::new(leaves),
             int96_as_datetime: int96AsDatetime,
-            metadata: None,
-            schema: None,
-            thrift: None,
+            footer_object: None,
             closed: false,
         })
     }
 
-    /// Closes the stream; any later call throws.
+    /// Closes the stream; any later call throws. A footer taken before stays readable.
     pub fn close(&mut self) -> PhpResult<()> {
         self.open()?;
         self.closed = true;
-        self.metadata = None;
-        self.schema = None;
-        self.thrift = None;
+        self.footer_object = None;
 
         match self.stream.call("close", &mut []) {
             Some(_) => Ok(()),
@@ -208,10 +323,65 @@ impl RustParquetFileReader {
         }
     }
 
-    /// The whole footer as `Metadata`, built on the first call.
-    pub fn metadata(&mut self) -> PhpResult<MetadataObject> {
+    /// The footer the constructor read, as a `RustParquetFooter` created on the first call.
+    pub fn footer(&mut self) -> PhpResult<FooterObject> {
+        self.open()?;
+
+        if let Some(footer) = &self.footer_object {
+            return Ok(FooterObject(footer.shallow_clone()));
+        }
+
+        let footer = ZendClassObject::new(RustParquetFooter {
+            stream: Arc::clone(&self.stream),
+            footer: Arc::clone(&self.footer),
+            leaves: Arc::clone(&self.leaves),
+            metadata: None,
+            schema: None,
+            thrift: None,
+        })
+        .into_zval(false)?;
+        self.footer_object = Some(footer.shallow_clone());
+
+        Ok(FooterObject(footer))
+    }
+
+    /// `$columns` (resolved names) in chunks of at most `$batchSize` rows, keyed by column, the rows `$plan` selects.
+    #[php(name = "readColumns")]
+    pub fn read_columns(&self, columns: &ZendHashTable, batchSize: i64, plan: &Zval) -> PhpResult<RustColumnsReader> {
         self.open()?;
+        self.refuse_int96(columns)?;
+
+        RustColumnsReader::__construct(self, columns, batchSize, plan)
+    }
+}
+
+#[php_class]
+#[php(
+    name = "Flow\\Parquet\\Engine\\RustParquetFooter",
+    flags = ClassFlags::Final,
+    implements(ce = footer_ce, stub = "Flow\\Parquet\\ParquetFile\\Footer")
+)]
+pub struct RustParquetFooter {
+    /// The stream the footer was read from, named in refusals.
+    stream: Arc<PhpStream>,
+    footer: Arc<Footer>,
+    leaves: Arc<HashMap<String, usize>>,
+    metadata: Option<Zval>,
+    schema: Option<Zval>,
+    thrift: Option<Zval>,
+}
+
+impl RustParquetFooter {
+    /// `FileMetaData::$schema`: the list of `SchemaElement`s.
+    fn elements(&self) -> PhpResult<Zval> {
+        thrift::decode(self.footer.bytes(), FILE_META_DATA, Some(SCHEMA))
+    }
+}
 
+#[php_impl]
+impl RustParquetFooter {
+    /// The whole footer as `Metadata`, built on the first call.
+    pub fn metadata(&mut self) -> PhpResult<MetadataObject> {
         if let Some(metadata) = &self.metadata {
             return Ok(MetadataObject(metadata.shallow_clone()));
         }
@@ -222,32 +392,71 @@ impl RustParquetFileReader {
         Ok(MetadataObject(metadata))
     }
 
-    /// `$columns` (resolved names) in chunks of at most `$batchSize` rows, keyed by column.
-    #[php(name = "readColumns")]
-    pub fn read_columns(
-        &self,
-        columns: &ZendHashTable,
-        batchSize: i64,
-        limit: Option<i64>,
-        offset: Option<i64>,
-    ) -> PhpResult<RustColumnsReader> {
-        self.open()?;
-        self.refuse_int96(columns)?;
+    /// `$columns` (`FlatColumn`s) as `RustRowGroupChunks`: each leaf's column chunks and column order sliced from
+    /// the footer, decoded by PHP on first access.
+    #[php(name = "rowGroupChunks")]
+    pub fn row_group_chunks(&self, columns: &ZendHashTable) -> PhpResult<RowGroupChunksObject> {
+        let meta = self.footer.meta();
+        let mut paths = Vec::with_capacity(columns.len());
+        let mut leaves = Vec::with_capacity(columns.len());
+
+        ht_for_each(columns, |_, _, column| {
+            let path = call_method(column, "flatPath", &mut [])?
+                .str()
+                .ok_or_else(|| exception(INVALID_ARGUMENT, "arrow expected a FlatColumn flat path".to_string()))?
+                .to_string();
+            let leaf = *self
+                .leaves
+                .get(&path)
+                .ok_or_else(|| exception(INVALID_ARGUMENT, format!("Parquet file has no leaf column \"{path}\"")))?;
+            paths.push(path);
+            leaves.push(leaf);
+
+            Ok::<(), PhpException>(())
+        })?;
+
+        let bytes = self.footer.bytes();
+        let spans = chunk_spans(bytes, &leaves).map_err(|error| parquet_exception(error, &self.stream, Side::Read))?;
+        let mut row_counts = ZendHashTable::with_capacity(meta.num_row_groups() as u32);
+
+        for (index, group) in meta.row_groups().iter().enumerate() {
+            ht_insert_long(&mut row_counts, index as i64, zval_long(group.num_rows()));
+        }
+
+        let mut chunks = ZendHashTable::with_capacity(paths.len() as u32);
+        let mut orders = ZendHashTable::with_capacity(paths.len() as u32);
+
+        for (position, (path, ranges)) in paths.iter().zip(spans.chunks).enumerate() {
+            let mut list = ZendHashTable::with_capacity(ranges.len() as u32);
+
+            for (group, range) in ranges.into_iter().enumerate() {
+                ht_insert_long(&mut list, group as i64, zval_str(&bytes[range]));
+            }
+
+            ht_insert(&mut chunks, path.as_bytes(), zval_array(list));
+            ht_insert(
+                &mut orders,
+                path.as_bytes(),
+                spans
+                    .orders
+                    .as_ref()
+                    .map_or_else(Zval::new, |orders| zval_str(&bytes[orders[position].clone()])),
+            );
+        }
 
-        RustColumnsReader::__construct(self, columns, batchSize, offset, limit)
+        Ok(RowGroupChunksObject(call_static(
+            ROW_GROUP_CHUNKS_FROM_THRIFT,
+            &mut [zval_array(row_counts), zval_array(chunks), zval_array(orders)],
+        )?))
     }
 
     #[php(name = "rowsNumber")]
-    pub fn rows_number(&self) -> PhpResult<i64> {
-        self.open()?;
-
-        Ok(self.footer.meta().file_metadata().num_rows())
+    pub fn rows_number(&self) -> i64 {
+        self.footer.meta().file_metadata().num_rows()
     }
 
     /// The file schema, without building the row-group metadata.
     pub fn schema(&mut self) -> PhpResult<SchemaObject> {
-        self.open()?;
-
         if let Some(metadata) = &self.metadata {
             return Ok(SchemaObject(call_method(metadata, "schema", &mut [])?));
         }
@@ -264,22 +473,17 @@ impl RustParquetFileReader {
 
     /// Σ row group `total_byte_size` (uncompressed).
     #[php(name = "totalByteSize")]
-    pub fn total_byte_size(&self) -> PhpResult<i64> {
-        self.open()?;
-
-        Ok(self
-            .footer
+    pub fn total_byte_size(&self) -> i64 {
+        self.footer
             .meta()
             .row_groups()
             .iter()
             .map(|group| group.total_byte_size())
-            .sum())
+            .sum()
     }
 
     /// The whole footer as `FileMetaData`, decoded on the first call.
     pub fn thrift(&mut self) -> PhpResult<Zval> {
-        self.open()?;
-
         if let Some(thrift) = &self.thrift {
             return Ok(thrift.shallow_clone());
         }
@@ -374,10 +578,7 @@ impl RustColumnsReader {
             ht_insert(&mut chunk, name, cell.values(array, self.times.as_ref())?);
         }
 
-        let mut zv = Zval::new();
-        zv.set_hashtable(chunk);
-
-        Ok(Some(zv))
+        Ok(Some(zval_array(chunk)))
     }
 }
 
@@ -388,13 +589,12 @@ impl RustColumnsReader {
         file: &RustParquetFileReader,
         columns: &ZendHashTable,
         batch_size: i64,
-        offset: Option<i64>,
-        limit: Option<i64>,
+        plan: &Zval,
     ) -> PhpResult<Self> {
         let batch_size = self::batch_size(batch_size)?;
-        let (offset, limit) = (rows(offset, "offset")?.unwrap_or(0), rows(limit, "limit")?);
-        let (stream, size, meta) = file.read()?;
+        let (stream, meta) = file.read()?;
         let stream = Arc::clone(stream);
+        let plan = read_plan(meta, plan, &stream)?;
         let refused = |error| parquet_exception(error, &stream, Side::Read);
         let mut names = Vec::with_capacity(columns.len());
 
@@ -410,18 +610,10 @@ impl RustColumnsReader {
                     .to_string(),
             );
 
-            Ok(())
+            Ok::<(), PhpException>(())
         })?;
 
-        let reader = ParquetReader::open(
-            Arc::clone(&stream),
-            size,
-            meta,
-            &names,
-            ReadPlan::new(meta, offset, limit),
-            batch_size,
-        )
-        .map_err(refused)?;
+        let reader = ParquetReader::open(Arc::clone(&stream), meta, &names, plan, batch_size).map_err(refused)?;
         let cells = reader
             .fields()
             .iter()
diff --git a/src/extension/arrow-ext/src/parquet/mod.rs b/src/extension/arrow-ext/src/parquet/mod.rs
index 3a3b825f67..2d090f889c 100644
--- a/src/extension/arrow-ext/src/parquet/mod.rs
+++ b/src/extension/arrow-ext/src/parquet/mod.rs
@@ -4,9 +4,10 @@
 pub mod batch;
 pub mod canonical;
 pub mod cells;
+pub mod chunks;
 pub mod engine;
 pub mod error;
-pub mod fetch;
+pub mod filter;
 pub mod footer;
 pub mod lib_calls;
 #[allow(
diff --git a/src/extension/arrow-ext/src/parquet/options.rs b/src/extension/arrow-ext/src/parquet/options.rs
index 99dbd48b40..379d41ac8c 100644
--- a/src/extension/arrow-ext/src/parquet/options.rs
+++ b/src/extension/arrow-ext/src/parquet/options.rs
@@ -1,8 +1,6 @@
-//! Ported verbatim from arrow-ext (`src/parquet/type_converter.rs` `parse_time_unit`, `php_schema_entry_to_field`,
-//! `php_schema_to_arrow`; `src/parquet/writer.rs` `parse_compression`, `parse_encoding`, `apply_writer_options` and
-//! the writer constructor's properties): the arrays of `Flow\Parquet\Engine\Arrow\SchemaConverter::toExtension()` and
-//! `OptionsConverter::toExtension()`.
+//! The arrays of `Flow\Parquet\Engine\Arrow\SchemaConverter::toExtension()` and `OptionsConverter::toExtension()`.
 
+use std::collections::HashMap;
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -10,12 +8,17 @@ use arrow_schema::{
     extension::{Json, Uuid},
     DataType, Field, Fields, Schema, TimeUnit,
 };
-use ext_php_rs::types::{ArrayKey, ZendHashTable};
+use ext_php_rs::ffi::zend_ulong;
+use ext_php_rs::types::{ZendHashTable, ZendStr};
 use parquet::basic::{BrotliLevel, Compression, Encoding, GzipLevel, ZstdLevel};
-use parquet::file::properties::{WriterProperties, WriterVersion};
+use parquet::file::properties::{EnabledStatistics, WriterProperties, WriterVersion, DEFAULT_WRITE_BATCH_SIZE};
 use parquet::schema::types::ColumnPath;
 
 use crate::parquet::error::Error;
+use crate::php::ht_for_each;
+
+/// Field metadata key of a Utf8 field written with the ENUM logical type, which no arrow data type carries.
+pub const ENUM_METADATA_KEY: &str = "flow.parquet.enum";
 
 pub fn schema(ht: &ZendHashTable) -> Result<Schema, Error> {
     php_schema_to_arrow(ht).map_err(Error::Options)
@@ -73,6 +76,10 @@ fn php_schema_entry_to_field(entry_ht: &ZendHashTable) -> Result<Field, String>
         "FLOAT" => DataType::Float32,
         "DOUBLE" => DataType::Float64,
         "STRING" => DataType::Utf8,
+        "ENUM" => {
+            return Ok(Field::new(&name, DataType::Utf8, nullable)
+                .with_metadata(HashMap::from([(ENUM_METADATA_KEY.to_string(), String::new())])));
+        }
         "BINARY" => DataType::Binary,
         "DATE" => DataType::Date32,
         "TIMESTAMP" => {
@@ -174,7 +181,8 @@ fn php_schema_entry_to_field(entry_ht: &ZendHashTable) -> Result<Field, String>
                     .ok_or_else(|| format!("Column '{}': MAP value child must be an array", name))?,
             )?;
             let entries_struct = DataType::Struct(Fields::from(vec![key_field, val_field]));
-            DataType::Map(Arc::new(Field::new("entries", entries_struct, false)), false)
+            // parquet-format LogicalTypes.md names the repeated group of a MAP `key_value`
+            DataType::Map(Arc::new(Field::new("key_value", entries_struct, false)), false)
         }
         other => {
             return Err(format!("Column '{}': Unsupported type '{}'", name, other));
@@ -265,6 +273,10 @@ fn apply_writer_options(
     builder = builder.set_compression(codec);
 
     if let Some(val) = options.get("ROW_GROUP_SIZE_BYTES").and_then(|z| z.long()) {
+        if val < 1 {
+            return Err(format!("ROW_GROUP_SIZE_BYTES must be greater than 0, {val} given"));
+        }
+
         builder = builder.set_max_row_group_bytes(Some(val as usize));
     }
 
@@ -272,6 +284,54 @@ fn apply_writer_options(
         builder = builder.set_data_page_size_limit(val as usize);
     }
 
+    if let Some(val) = options.get("PAGE_MAXIMUM_ROWS_COUNT").and_then(|z| z.long()) {
+        if val < 1 {
+            return Err(format!("PAGE_MAXIMUM_ROWS_COUNT must be greater than 0, {val} given"));
+        }
+
+        // arrow-rs checks the page row limit once per write batch: a smaller batch closes pages where PHP does
+        builder = builder
+            .set_data_page_row_count_limit(val as usize)
+            .set_write_batch_size((val as usize).min(DEFAULT_WRITE_BATCH_SIZE));
+    }
+
+    if let Some(val) = options.get("STATISTICS_TRUNCATE_LENGTH").and_then(|z| z.long()) {
+        if val < 1 {
+            return Err(format!(
+                "STATISTICS_TRUNCATE_LENGTH must be greater than 0, {val} given"
+            ));
+        }
+
+        builder = builder.set_statistics_truncate_length(Some(val as usize));
+    }
+
+    if let Some(val) = options.get("COLUMN_INDEX_TRUNCATE_LENGTH").and_then(|z| z.long()) {
+        if val < 1 {
+            return Err(format!(
+                "COLUMN_INDEX_TRUNCATE_LENGTH must be greater than 0, {val} given"
+            ));
+        }
+
+        builder = builder.set_column_index_truncate_length(Some(val as usize));
+    }
+
+    if let Some(level) = options.get("STATISTICS_LEVEL").and_then(|z| z.str()) {
+        builder = builder.set_statistics_enabled(match level {
+            "NONE" => EnabledStatistics::None,
+            "CHUNK" => EnabledStatistics::Chunk,
+            "PAGE" => EnabledStatistics::Page,
+            other => {
+                return Err(format!(
+                    "Invalid STATISTICS_LEVEL '{other}'. Must be NONE, CHUNK or PAGE"
+                ))
+            }
+        });
+    }
+
+    if let Some(enabled) = options.get("PAGE_HEADER_STATISTICS").and_then(|z| z.bool()) {
+        builder = builder.set_write_page_header_statistics(enabled);
+    }
+
     if let Some(val) = options.get("DICTIONARY_PAGE_SIZE").and_then(|z| z.long()) {
         builder = builder.set_dictionary_page_size_limit(val as usize);
     }
@@ -285,41 +345,108 @@ fn apply_writer_options(
         builder = builder.set_writer_version(version);
     }
 
-    if let Some(col_comp_zval) = options.get("COLUMNS_COMPRESSIONS") {
-        if let Some(col_comp_ht) = col_comp_zval.array() {
-            for (key, val) in col_comp_ht.iter() {
-                let col_path_str = match key {
-                    ArrayKey::String(ref s) => s.clone(),
-                    ArrayKey::Str(s) => s.to_string(),
-                    _ => continue,
-                };
-                if let Some(codec_str) = val.str() {
-                    let parts: Vec<String> = col_path_str.split('.').map(|s| s.to_string()).collect();
-                    let col_path = ColumnPath::new(parts);
-                    let col_codec = parse_compression(codec_str, gzip_level, brotli_level, zstd_level)?;
-                    builder = builder.set_column_compression(col_path, col_codec);
-                }
-            }
+    if let Some(columns) = options.get("COLUMNS_COMPRESSIONS").and_then(|z| z.array()) {
+        let mut compressions = Vec::new();
+
+        ht_for_each(columns, |key, index, value| {
+            let path = column_key("COLUMNS_COMPRESSIONS", key, index)?;
+            let codec = value
+                .str()
+                .ok_or_else(|| format!("COLUMNS_COMPRESSIONS['{path}'] must be a string"))?;
+            compressions.push((
+                column_path(&path),
+                parse_compression(codec, gzip_level, brotli_level, zstd_level)?,
+            ));
+
+            Ok::<(), String>(())
+        })?;
+
+        for (path, codec) in compressions {
+            builder = builder.set_column_compression(path, codec);
         }
     }
 
-    if let Some(col_enc_zval) = options.get("COLUMNS_ENCODINGS") {
-        if let Some(col_enc_ht) = col_enc_zval.array() {
-            for (key, val) in col_enc_ht.iter() {
-                let col_path_str = match key {
-                    ArrayKey::String(ref s) => s.clone(),
-                    ArrayKey::Str(s) => s.to_string(),
-                    _ => continue,
-                };
-                if let Some(enc_str) = val.str() {
-                    let parts: Vec<String> = col_path_str.split('.').map(|s| s.to_string()).collect();
-                    let col_path = ColumnPath::new(parts);
-                    let encoding = parse_encoding(enc_str)?;
-                    builder = builder.set_column_encoding(col_path, encoding);
+    if let Some(columns) = options.get("COLUMNS_ENCODINGS").and_then(|z| z.array()) {
+        let mut encodings = Vec::new();
+
+        ht_for_each(columns, |key, index, value| {
+            let path = column_key("COLUMNS_ENCODINGS", key, index)?;
+            let encoding = value
+                .str()
+                .ok_or_else(|| format!("COLUMNS_ENCODINGS['{path}'] must be a string"))?;
+            encodings.push((column_path(&path), parse_encoding(encoding)?));
+
+            Ok::<(), String>(())
+        })?;
+
+        for (path, encoding) in encodings {
+            // arrow-rs panics on a dictionary encoding set as the column encoding: the dictionary is its own flag
+            builder = match encoding {
+                Encoding::PLAIN_DICTIONARY | Encoding::RLE_DICTIONARY => {
+                    builder.set_column_dictionary_enabled(path, true)
                 }
+                encoding => builder.set_column_encoding(path, encoding),
+            };
+        }
+    }
+
+    if let Some(columns) = options.get("COLUMNS_BLOOM_FILTERS").and_then(|z| z.array()) {
+        let mut filters = Vec::new();
+
+        ht_for_each(columns, |key, index, value| {
+            let path = column_key("COLUMNS_BLOOM_FILTERS", key, index)?;
+            let filter = value
+                .array()
+                .ok_or_else(|| format!("COLUMNS_BLOOM_FILTERS['{path}'] must be an array"))?;
+            let fpp = filter
+                .get("fpp")
+                .and_then(|z| z.double())
+                .ok_or_else(|| format!("COLUMNS_BLOOM_FILTERS['{path}'] has no float fpp"))?;
+
+            if !(fpp > 0.0 && fpp < 1.0) {
+                return Err(format!(
+                    "COLUMNS_BLOOM_FILTERS['{path}'] fpp must be greater than 0 and less than 1, {fpp} given"
+                ));
+            }
+
+            let ndv = filter
+                .get("ndv")
+                .and_then(|z| z.long())
+                .map(|ndv| {
+                    u64::try_from(ndv).map_err(|_| format!("COLUMNS_BLOOM_FILTERS['{path}'] ndv must not be negative"))
+                })
+                .transpose()?;
+
+            filters.push((column_path(&path), fpp, ndv));
+
+            Ok::<(), String>(())
+        })?;
+
+        for (path, fpp, ndv) in filters {
+            builder = builder
+                .set_column_bloom_filter_enabled(path.clone(), true)
+                .set_column_bloom_filter_fpp(path.clone(), fpp);
+
+            if let Some(ndv) = ndv {
+                builder = builder.set_column_bloom_filter_max_ndv(path, ndv);
             }
         }
     }
 
     Ok(builder)
 }
+
+/// A `COLUMNS_*` option's key as a column path; PHP keys a digit-only path by its integer.
+fn column_key(option: &str, key: Option<&ZendStr>, index: zend_ulong) -> Result<String, String> {
+    match key {
+        Some(key) => key
+            .as_str()
+            .map(str::to_string)
+            .map_err(|_| format!("{option} has a key that is not a column path")),
+        None => Ok(index.to_string()),
+    }
+}
+
+fn column_path(path: &str) -> ColumnPath {
+    ColumnPath::new(path.split('.').map(str::to_string).collect())
+}
diff --git a/src/extension/arrow-ext/src/parquet/read.rs b/src/extension/arrow-ext/src/parquet/read.rs
index 5c7f127fc5..4a7f7fac0e 100644
--- a/src/extension/arrow-ext/src/parquet/read.rs
+++ b/src/extension/arrow-ext/src/parquet/read.rs
@@ -1,56 +1,113 @@
-//! Row groups of a Parquet file as canonical arrays: only the groups an offset/limit window overlaps are decoded, and
-//! every projected column is checked against the cast table before the first batch.
+//! Row groups of a Parquet file as canonical arrays: only the groups a read plan selects rows of are decoded, and only
+//! the byte ranges arrow-rs's push decoder asks for are read - the selected pages when a plan skips rows inside a
+//! group, whole projected chunks otherwise. Every projected column is checked against the cast table before the first
+//! batch.
 
+use std::ops::Range;
 use std::sync::Arc;
 
 use arrow_array::cast::AsArray;
-use arrow_array::{make_array, Array, ArrayRef, RecordBatchReader};
+use arrow_array::{make_array, Array, ArrayRef};
 use arrow_buffer::NullBuffer;
 use arrow_schema::{DataType, Field, FieldRef, Fields, Schema, SchemaRef, TimeUnit};
 use parquet::arrow::arrow_reader::{
-    ArrowReaderMetadata, ArrowReaderOptions, ParquetRecordBatchReader, ParquetRecordBatchReaderBuilder,
+    ArrowPredicate, ArrowReaderMetadata, ArrowReaderOptions, RowFilter, RowSelection, RowSelector,
 };
+use parquet::arrow::push_decoder::{ParquetPushDecoder, ParquetPushDecoderBuilder, RowGroupSelection};
 use parquet::arrow::ProjectionMask;
 use parquet::basic::{Compression, Type};
-use parquet::file::metadata::{PageIndexPolicy, ParquetMetaData, ParquetMetaDataReader};
+use parquet::file::metadata::page_index::PageIndexBuilder;
+use parquet::file::metadata::ParquetMetaData;
+use parquet::file::page_index::index_reader::decode_offset_index;
 use parquet::schema::types::SchemaDescriptor;
+use parquet::DecodeResult;
 
 use crate::parquet::canonical::{canonical, canonical_type};
 use crate::parquet::error::Error;
-use crate::parquet::fetch::ChunkFetch;
-use crate::parquet::source::ReadAt;
+use crate::parquet::filter::{PlanPredicate, Raw};
+use crate::parquet::source::{exact, ReadAt};
 
-/// The row groups overlapping [offset, offset + limit) and the rows to skip in the first of them.
-#[derive(Debug, PartialEq, Eq)]
+/// The row groups holding a selected row, each with its row-group-local selection - `None` when every row of the
+/// group is selected - the row filter evaluated on the selected rows, and the rows returned at most, counted after it.
+#[derive(Debug, PartialEq)]
 pub struct ReadPlan {
-    pub row_groups: Vec<usize>,
-    pub skip: usize,
+    pub selections: Vec<RowGroupSelection>,
+    pub filter: Option<Raw>,
     pub limit: Option<usize>,
 }
 
 impl ReadPlan {
-    pub fn new(meta: &ParquetMetaData, offset: u64, limit: Option<u64>) -> Self {
-        let (mut row_groups, mut skip, mut start) = (Vec::new(), 0, 0);
+    /// `selectors`: (row count, skip) over every row of the file, `filter` the row filter and `limit` the rows returned
+    /// at most, as `ReadPlanConverter::toExtension()` sends them.
+    pub fn from_selection(
+        meta: &ParquetMetaData,
+        selectors: Vec<(usize, bool)>,
+        filter: Option<Raw>,
+        limit: Option<usize>,
+    ) -> Result<Self, Error> {
+        let total = selectors
+            .iter()
+            .try_fold(0usize, |total, (count, _)| total.checked_add(*count))
+            .ok_or_else(|| Error::Plan("A read plan's row counts overflow".to_string()))?;
+        let rows = meta
+            .row_groups()
+            .iter()
+            .try_fold(0usize, |rows, group| {
+                rows.checked_add(usize::try_from(group.num_rows()).ok()?)
+            })
+            .ok_or_else(|| {
+                Error::NotParquet("Invalid Parquet file. The row groups' row counts overflow".to_string())
+            })?;
+
+        if total != rows {
+            return Err(Error::Plan(format!(
+                "A read plan over {total} rows cannot read a file of {rows} rows"
+            )));
+        }
 
-        for (index, group) in meta.row_groups().iter().enumerate() {
-            let end = start + group.num_rows() as u64;
+        let mut selections = Vec::new();
+        let mut selectors = selectors.into_iter().filter(|(count, _)| *count > 0);
+        let mut current = selectors.next();
 
-            if end > offset && limit.is_none_or(|limit| start < offset + limit) {
-                if row_groups.is_empty() {
-                    skip = (offset - start) as usize;
+        for (index, group) in meta.row_groups().iter().enumerate() {
+            let mut remaining = group.num_rows() as usize;
+            let mut kept = Vec::new();
+
+            while remaining > 0 {
+                // the totals are equal: a selector is left while a group has rows
+                let Some((count, skip)) = current.as_mut() else {
+                    break;
+                };
+                let taken = (*count).min(remaining);
+                kept.push(if *skip {
+                    RowSelector::skip(taken)
+                } else {
+                    RowSelector::select(taken)
+                });
+                *count -= taken;
+                remaining -= taken;
+
+                if *count == 0 {
+                    current = selectors.next();
                 }
-
-                row_groups.push(index);
             }
 
-            start = end;
+            if kept.iter().all(|selector| !selector.skip) {
+                selections.push(RowGroupSelection::new(index, None));
+            } else if kept.iter().any(|selector| !selector.skip) {
+                selections.push(RowGroupSelection::new(index, Some(RowSelection::from(kept))));
+            }
         }
 
-        Self {
-            row_groups,
-            skip,
-            limit: limit.map(|limit| limit as usize),
-        }
+        Ok(Self {
+            selections,
+            filter,
+            limit,
+        })
+    }
+
+    pub fn row_groups(&self) -> Vec<usize> {
+        self.selections.iter().map(RowGroupSelection::row_group_index).collect()
     }
 }
 
@@ -71,27 +128,16 @@ impl Projected {
             });
         }
 
-        let missing = || Error::MissingColumn(name.to_string());
-        let mut segments = name.split('.');
-        let root = segments.next().ok_or_else(missing)?;
-        let mut field = schema.field_with_name(root).map_err(|_| missing())?;
-        let mut nullable = field.is_nullable();
-        let mut path = vec![root.to_string()];
-
-        for segment in segments {
-            field = match field.data_type() {
-                DataType::Struct(children) => children.find(segment).ok_or_else(missing)?.1,
-                DataType::List(_) | DataType::LargeList(_) | DataType::FixedSizeList(_, _) | DataType::Map(_, _) => {
-                    return Err(Error::Unsupported {
-                        column: name.to_string(),
-                        parquet: "a path into LIST/MAP".to_string(),
-                    })
+        let path = name.split('.').map(str::to_string).collect::<Vec<_>>();
+        let (field, nullable) = struct_field(schema, &path).map_err(|parent| match parent.map(Field::data_type) {
+            Some(DataType::List(_) | DataType::LargeList(_) | DataType::FixedSizeList(_, _) | DataType::Map(_, _)) => {
+                Error::Unsupported {
+                    column: name.to_string(),
+                    parquet: "a path into LIST/MAP".to_string(),
                 }
-                _ => return Err(missing()),
-            };
-            nullable |= field.is_nullable();
-            path.push(segment.to_string());
-        }
+            }
+            _ => Error::MissingColumn(name.to_string()),
+        })?;
 
         Ok(Self {
             path,
@@ -105,7 +151,8 @@ impl Projected {
 }
 
 pub struct ParquetReader {
-    batches: ParquetRecordBatchReader,
+    decoder: ParquetPushDecoder,
+    source: Arc<dyn ReadAt + Send + Sync>,
     /// Each column's field as the file stores it, named as it was asked for.
     fields: Vec<FieldRef>,
     /// `canonical_type()` of each of `fields`.
@@ -115,12 +162,9 @@ pub struct ParquetReader {
 }
 
 impl ParquetReader {
-    /// `source`: the file's bytes (`PhpStream`), `size` long; `meta`: its footer, which `plan` was built from. Only
-    /// the projected column chunks of the planned row groups are fetched (`ChunkFetch`); the page index is read on a
-    /// copy of `meta`, only when the plan skips rows inside its first row group.
+    /// `source`: the file's bytes (`PhpStream`); `meta`: its footer without page indexes, which `plan` was built from. Offset indexes are loaded for the projected and predicate leaves of the groups the plan reads in part, and of every planned group when the plan has a row filter.
     pub fn open<R: ReadAt + Send + Sync + 'static>(
         source: Arc<R>,
-        size: u64,
         meta: &Arc<ParquetMetaData>,
         columns: &[String],
         plan: ReadPlan,
@@ -147,57 +191,51 @@ impl ParquetReader {
             .map(|field| canonical_type(field))
             .collect::<Result<Vec<_>, _>>()?;
 
-        if let Some(codec) = unsupported_codec(meta, &plan.row_groups, &projected) {
+        let descr = meta.file_metadata().schema_descr();
+        let predicates = match &plan.filter {
+            Some(filter) => PlanPredicate::conjuncts(filter, &schema, descr)?,
+            None => Vec::new(),
+        };
+        let predicated = predicates
+            .iter()
+            .flat_map(|predicate| predicate.leaves().iter().copied())
+            .collect::<Vec<_>>();
+
+        if let Some(codec) = unsupported_codec(meta, &plan.row_groups(), &projected, &predicated) {
             return Err(codec);
         }
 
-        let descr = meta.file_metadata().schema_descr();
-        let leaves = (0..descr.num_columns())
-            .filter(|leaf| {
-                projected
-                    .iter()
-                    .any(|column| column.reads_leaf(descr.column(*leaf).path().parts()))
-            })
+        let source: Arc<dyn ReadAt + Send + Sync> = source;
+        let leaves = projected_leaves(descr, &projected);
+        let fetched = (0..descr.num_columns())
+            .filter(|leaf| leaves.contains(leaf) || predicated.contains(leaf))
             .collect::<Vec<_>>();
-        let fetch = ChunkFetch::new(source, size, meta, &plan.row_groups, &leaves);
-        let meta = if plan.skip > 0 {
-            let mut reader = ParquetMetaDataReader::new_with_metadata(meta.as_ref().clone())
-                .with_page_index_policy(PageIndexPolicy::Optional);
-            reader.read_page_indexes(&fetch)?;
-            ArrowReaderMetadata::try_new(Arc::new(reader.finish()?), options)?
-        } else {
-            ArrowReaderMetadata::try_new(Arc::clone(meta), options)?
-        };
+        let meta = ArrowReaderMetadata::try_new(with_offset_index(source.as_ref(), meta, &plan, &fetched)?, options)?;
         let mask = ProjectionMask::leaves(meta.metadata().file_metadata().schema_descr(), leaves);
-        let mut builder = ParquetRecordBatchReaderBuilder::new_with_metadata(fetch, meta)
-            .with_row_groups(plan.row_groups)
+        let mut builder = ParquetPushDecoderBuilder::new_with_metadata(meta)
+            .with_row_group_selections(plan.selections)
             .with_projection(mask)
             .with_batch_size(batch_size);
 
-        if plan.skip > 0 {
-            builder = builder.with_offset(plan.skip);
+        if !predicates.is_empty() {
+            builder = builder.with_row_filter(RowFilter::new(
+                predicates
+                    .into_iter()
+                    .map(|predicate| Box::new(predicate) as Box<dyn ArrowPredicate>)
+                    .collect(),
+            ));
         }
 
         if let Some(limit) = plan.limit {
             builder = builder.with_limit(limit);
         }
 
-        let batches = builder.build()?;
-        let schema = batches.schema();
-        let positions = projected
-            .into_iter()
-            .map(|mut column| {
-                let root = schema
-                    .index_of(&column.path[0])
-                    .map_err(|_| Error::MissingColumn(column.field.name().clone()))?;
-                column.path.remove(0);
-
-                Ok((root, column.path))
-            })
-            .collect::<Result<Vec<_>, Error>>()?;
+        let decoder = builder.build()?;
+        let positions = positions(&schema, &projected)?;
 
         Ok(Self {
-            batches,
+            decoder,
+            source,
             fields,
             types,
             positions,
@@ -214,9 +252,19 @@ impl ParquetReader {
     }
 
     pub fn next(&mut self) -> Option<Result<(usize, Vec<ArrayRef>), Error>> {
-        let batch = match self.batches.next()? {
-            Ok(batch) => batch,
-            Err(error) => return Some(Err(error.into())),
+        let batch = loop {
+            match self.decoder.try_decode() {
+                Ok(DecodeResult::NeedsData(ranges)) => {
+                    if let Err(error) = read_ranges(self.source.as_ref(), ranges)
+                        .and_then(|(ranges, bytes)| Ok(self.decoder.push_ranges(ranges, bytes)?))
+                    {
+                        return Some(Err(error));
+                    }
+                }
+                Ok(DecodeResult::Data(batch)) => break batch,
+                Ok(DecodeResult::Finished) => return None,
+                Err(error) => return Some(Err(error.into())),
+            }
         };
 
         Some(
@@ -230,25 +278,161 @@ impl ParquetReader {
     }
 }
 
-/// The struct child at `path` under `array`, null wherever a struct above it is.
-fn child(array: &ArrayRef, path: &[String]) -> Result<ArrayRef, Error> {
+/// The bytes of `ranges`, read adjacent runs at a time and handed back per range asked: the decoder releases a pushed
+/// buffer only when its range is one it asked for.
+fn read_ranges(source: &dyn ReadAt, ranges: Vec<Range<u64>>) -> Result<(Vec<Range<u64>>, Vec<bytes::Bytes>), Error> {
+    let reads = coalesced(ranges.clone())
+        .into_iter()
+        .map(|read| Ok((read.start, exact(source, read.start, (read.end - read.start) as usize)?)))
+        .collect::<Result<Vec<_>, Error>>()?;
+    let bytes = ranges
+        .iter()
+        .map(|range| {
+            let (start, bytes) = &reads[reads.partition_point(|(start, _)| *start <= range.start) - 1];
+
+            bytes.slice((range.start - start) as usize..(range.end - start) as usize)
+        })
+        .collect();
+
+    Ok((ranges, bytes))
+}
+
+/// `meta` with the offset index of each fetched leaf of the row groups `plan` reads in part, or of every planned group
+/// when a row filter can narrow it, where the selected pages are worth finding; every other chunk is fetched whole, as
+/// without an index.
+fn with_offset_index(
+    source: &dyn ReadAt,
+    meta: &Arc<ParquetMetaData>,
+    plan: &ReadPlan,
+    leaves: &[usize],
+) -> Result<Arc<ParquetMetaData>, Error> {
+    let indexed = plan
+        .selections
+        .iter()
+        .filter(|group| plan.filter.is_some() || group.selection().is_some())
+        .flat_map(|group| leaves.iter().map(move |leaf| (group.row_group_index(), *leaf)))
+        .filter_map(|(group, leaf)| Some((group, leaf, meta.row_group(group).column(leaf).offset_index_range()?)))
+        .collect::<Vec<_>>();
+
+    if indexed.is_empty() {
+        return Ok(Arc::clone(meta));
+    }
+
+    let (_, bytes) = read_ranges(source, indexed.iter().map(|(_, _, range)| range.clone()).collect())?;
+    let mut page_index =
+        PageIndexBuilder::new(meta.num_row_groups(), meta.file_metadata().schema_descr().num_columns());
+
+    for ((group, leaf, _), bytes) in indexed.into_iter().zip(bytes) {
+        page_index.put_offset_index(decode_offset_index(&bytes)?, group, leaf);
+    }
+
+    Ok(Arc::new(
+        ParquetMetaData::clone(meta)
+            .into_builder()
+            .set_page_index(Some(Arc::new(page_index.build())))
+            .build(),
+    ))
+}
+
+/// The parquet leaves a projected column reads, in the file's order.
+fn projected_leaves(descr: &SchemaDescriptor, projected: &[Projected]) -> Vec<usize> {
+    (0..descr.num_columns())
+        .filter(|leaf| {
+            projected
+                .iter()
+                .any(|column| column.reads_leaf(descr.column(*leaf).path().parts()))
+        })
+        .collect()
+}
+
+/// Where each projected column sits in a batch, which holds the roots with a projected leaf in the file's order: its
+/// root, then the struct children down to it.
+fn positions(schema: &Schema, projected: &[Projected]) -> Result<Vec<(usize, Vec<String>)>, Error> {
+    let roots = schema
+        .fields()
+        .iter()
+        .map(|field| field.name())
+        .filter(|name| projected.iter().any(|column| &column.path[0] == *name))
+        .collect::<Vec<_>>();
+
+    projected
+        .iter()
+        .map(|column| {
+            let root = roots
+                .iter()
+                .position(|name| *name == &column.path[0])
+                .ok_or_else(|| Error::MissingColumn(column.field.name().clone()))?;
+
+            Ok((root, column.path[1..].to_vec()))
+        })
+        .collect()
+}
+
+/// Sorted ranges with every run of adjacent or overlapping ones merged.
+fn coalesced(mut ranges: Vec<Range<u64>>) -> Vec<Range<u64>> {
+    ranges.sort_by_key(|range| range.start);
+    let mut merged: Vec<Range<u64>> = Vec::with_capacity(ranges.len());
+
+    for range in ranges {
+        match merged.last_mut() {
+            Some(last) if last.end >= range.start => last.end = last.end.max(range.end),
+            _ => merged.push(range),
+        }
+    }
+
+    merged
+}
+
+/// The struct child at `path` under `schema`'s roots and whether it or a struct above it is nullable; `Err` holds the
+/// field a segment is no child of, `None` when no root is named `path[0]`.
+pub fn struct_field<'a>(schema: &'a Schema, path: &[String]) -> Result<(&'a Field, bool), Option<&'a Field>> {
+    let mut field = schema.field_with_name(&path[0]).map_err(|_| None)?;
+    let mut nullable = field.is_nullable();
+
+    for name in &path[1..] {
+        field = match field.data_type() {
+            DataType::Struct(children) => children.find(name).ok_or(Some(field))?.1,
+            _ => return Err(Some(field)),
+        };
+        nullable |= field.is_nullable();
+    }
+
+    Ok((field, nullable))
+}
+
+/// The struct child at `path` under `array`, with the nulls of it and of every struct above it.
+pub fn struct_child(array: &ArrayRef, path: &[String]) -> Result<(ArrayRef, Option<NullBuffer>), Error> {
     let mut array = Arc::clone(array);
+    let mut nulls = array.nulls().cloned();
 
     for name in path {
-        let structure = array.as_struct();
-        let child = structure
-            .column_by_name(name)
-            .ok_or_else(|| Error::MissingColumn(name.clone()))?;
-
-        array = match NullBuffer::union(structure.nulls(), child.nulls()) {
-            Some(nulls) if structure.nulls().is_some() => {
-                make_array(child.to_data().into_builder().nulls(Some(nulls)).build()?)
-            }
-            _ => Arc::clone(child),
-        };
+        let child = Arc::clone(
+            array
+                .as_struct()
+                .column_by_name(name)
+                .ok_or_else(|| Error::MissingColumn(name.clone()))?,
+        );
+        nulls = NullBuffer::union(nulls.as_ref(), child.nulls());
+        array = child;
     }
 
-    Ok(array)
+    Ok((array, nulls))
+}
+
+/// The struct child at `path` under `array`, null wherever a struct above it is.
+fn child(array: &ArrayRef, path: &[String]) -> Result<ArrayRef, Error> {
+    let (child, nulls) = struct_child(array, path)?;
+
+    // a union only adds nulls: as many as the child's own means none was added
+    if nulls.as_ref().map(NullBuffer::null_count) == child.nulls().map(NullBuffer::null_count) {
+        return Ok(child);
+    }
+
+    // SAFETY: the union of the structs' and the child's null buffers has the child's length, and nulling a slot keeps
+    // every other buffer of the child valid
+    Ok(make_array(unsafe {
+        child.to_data().into_builder().nulls(nulls).build_unchecked()
+    }))
 }
 
 /// The inferred schema with every INT96 leaf read as `Timestamp(µs, "UTC")` - exact over years 1 to 9999, where
@@ -290,19 +474,33 @@ fn int96_hinted(field: &FieldRef, descr: &SchemaDescriptor, leaf: &mut usize, hi
     Arc::new(Field::clone(field).with_data_type(data_type))
 }
 
-/// A codec the parquet crate is built without, in a projected column chunk of the planned row groups.
-fn unsupported_codec(meta: &ParquetMetaData, row_groups: &[usize], columns: &[Projected]) -> Option<Error> {
+/// A codec the parquet crate is built without, in a projected or `predicated` leaf's chunk of the planned row groups.
+fn unsupported_codec(
+    meta: &ParquetMetaData,
+    row_groups: &[usize],
+    columns: &[Projected],
+    predicated: &[usize],
+) -> Option<Error> {
     row_groups.iter().find_map(|group| {
-        meta.row_group(*group).columns().iter().find_map(|chunk| {
-            let column = columns
-                .iter()
-                .find(|column| column.reads_leaf(chunk.column_path().parts()))?;
-
-            (chunk.compression() == Compression::LZO).then(|| Error::Unsupported {
-                column: column.field.name().clone(),
-                parquet: "LZO".to_string(),
+        meta.row_group(*group)
+            .columns()
+            .iter()
+            .enumerate()
+            .find_map(|(leaf, chunk)| {
+                let column = match columns
+                    .iter()
+                    .find(|column| column.reads_leaf(chunk.column_path().parts()))
+                {
+                    Some(column) => column.field.name().clone(),
+                    None if predicated.contains(&leaf) => chunk.column_path().string(),
+                    None => return None,
+                };
+
+                (chunk.compression() == Compression::LZO).then(|| Error::Unsupported {
+                    column,
+                    parquet: "LZO".to_string(),
+                })
             })
-        })
     })
 }
 
@@ -317,21 +515,25 @@ mod tests {
     use arrow_buffer::NullBuffer;
     use arrow_schema::{DataType, Field, Fields, Schema, TimeUnit};
     use bytes::Bytes;
+    use parquet::arrow::arrow_reader::{RowSelection, RowSelector};
+    use parquet::arrow::push_decoder::RowGroupSelection;
     use parquet::arrow::ArrowWriter;
     use parquet::basic::Compression;
     use parquet::data_type::{Int64Type, Int96, Int96Type};
-    use parquet::file::metadata::{ParquetMetaData, ParquetMetaDataReader};
+    use parquet::file::metadata::{FileMetaData, PageIndexPolicy, ParquetMetaData, ParquetMetaDataReader};
     use parquet::file::properties::WriterProperties;
     use parquet::file::writer::SerializedFileWriter;
     use parquet::schema::parser::parse_message_type;
     use parquet::schema::types::SchemaDescriptor;
 
-    use super::{int96_hint, unsupported_codec, ParquetReader, Projected, ReadPlan};
+    use super::{coalesced, int96_hint, unsupported_codec, ParquetReader, Projected, ReadPlan};
     use crate::parquet::error::Error;
+    use crate::parquet::filter::Raw;
     use crate::parquet::footer::Footer;
     use crate::parquet::source::fake::Counting;
 
-    fn eight_groups_of_8192() -> parquet::file::metadata::ParquetMetaData {
+    /// Three row groups of 100 rows.
+    fn three_groups() -> ParquetMetaData {
         let schema = Arc::new(Schema::new(vec![Field::new("id", DataType::Int64, false)]));
         let mut file = Vec::new();
         let mut writer = ArrowWriter::try_new(
@@ -339,13 +541,13 @@ mod tests {
             Arc::clone(&schema),
             Some(
                 WriterProperties::builder()
-                    .set_max_row_group_row_count(Some(8_192))
+                    .set_max_row_group_row_count(Some(100))
                     .build(),
             ),
         )
         .unwrap();
         writer
-            .write(&RecordBatch::try_new(schema, vec![Arc::new(Int64Array::from_iter_values(0..65_536))]).unwrap())
+            .write(&RecordBatch::try_new(schema, vec![Arc::new(Int64Array::from_iter_values(0..300))]).unwrap())
             .unwrap();
         writer.close().unwrap();
 
@@ -354,36 +556,122 @@ mod tests {
             .unwrap()
     }
 
-    fn plan(offset: u64, limit: u64) -> (Vec<usize>, usize) {
-        let plan = ReadPlan::new(&eight_groups_of_8192(), offset, Some(limit));
+    #[test]
+    fn a_selection_keeps_the_groups_it_selects_rows_of_each_with_its_local_selection() {
+        let plan =
+            ReadPlan::from_selection(&three_groups(), vec![(150, true), (20, false), (130, true)], None, None).unwrap();
+
+        assert_eq!(
+            plan.selections,
+            vec![RowGroupSelection::new(
+                1,
+                Some(RowSelection::from(vec![
+                    RowSelector::skip(50),
+                    RowSelector::select(20),
+                    RowSelector::skip(30)
+                ]))
+            )]
+        );
+    }
+
+    #[test]
+    fn a_group_with_no_selected_row_is_dropped_and_a_whole_group_has_no_selection() {
+        let plan = ReadPlan::from_selection(
+            &three_groups(),
+            vec![
+                (10, true),
+                (90, false),
+                (100, true),
+                (50, false),
+                (0, false),
+                (50, true),
+            ],
+            None,
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(
+            plan.selections,
+            vec![
+                RowGroupSelection::new(
+                    0,
+                    Some(RowSelection::from(vec![RowSelector::skip(10), RowSelector::select(90)]))
+                ),
+                RowGroupSelection::new(
+                    2,
+                    Some(RowSelection::from(vec![RowSelector::select(50), RowSelector::skip(50)]))
+                ),
+            ]
+        );
+        assert_eq!(
+            ReadPlan::from_selection(&three_groups(), vec![(100, true), (200, false)], None, None)
+                .unwrap()
+                .selections,
+            vec![RowGroupSelection::new(1, None), RowGroupSelection::new(2, None)]
+        );
+    }
 
-        assert_eq!(plan.limit, Some(limit as usize));
+    #[test]
+    fn a_selection_of_no_row_reads_no_group() {
+        let plan = ReadPlan::from_selection(&three_groups(), vec![(300, true)], None, None).unwrap();
 
-        (plan.row_groups, plan.skip)
+        assert!(plan.selections.is_empty());
     }
 
     #[test]
-    fn plan_reads_the_groups_a_window_overlaps() {
-        assert_eq!(eight_groups_of_8192().row_groups().len(), 8);
-        assert_eq!(plan(0, 10), (vec![0], 0));
-        assert_eq!(plan(5_399, 3), (vec![0], 5_399));
-        assert_eq!(plan(20_000, 15_000), (vec![2, 3, 4], 3_616));
-        assert_eq!(plan(65_000, 100), (vec![7], 7_656));
-        assert_eq!(plan(65_046, 1), (vec![7], 7_702));
+    fn a_selection_that_does_not_cover_the_file_is_refused() {
+        for selectors in [vec![(299, false)], vec![(300, false), (1, true)], vec![]] {
+            assert!(matches!(
+                ReadPlan::from_selection(&three_groups(), selectors, None, None),
+                Err(Error::Plan(message)) if message.ends_with("cannot read a file of 300 rows")
+            ));
+        }
     }
 
     #[test]
-    fn plan_without_limit_reads_every_group_from_the_offset() {
-        let plan = ReadPlan::new(&eight_groups_of_8192(), 16_384, None);
+    fn selector_counts_that_overflow_are_refused() {
+        assert!(matches!(
+            ReadPlan::from_selection(&three_groups(), vec![(usize::MAX, false), (301, true)], None, None),
+            Err(Error::Plan(message)) if message == "A read plan's row counts overflow"
+        ));
+    }
 
-        assert_eq!(
-            plan,
-            ReadPlan {
-                row_groups: vec![2, 3, 4, 5, 6, 7],
-                skip: 0,
-                limit: None
+    /// `three_groups()` whose file metadata claims `num_rows` rows.
+    fn claiming(num_rows: i64) -> ParquetMetaData {
+        let meta = three_groups();
+        let file = meta.file_metadata();
+
+        ParquetMetaData::new(
+            FileMetaData::new(
+                file.version(),
+                num_rows,
+                file.created_by().map(str::to_string),
+                file.key_value_metadata().cloned(),
+                file.schema_descr_ptr(),
+                file.column_orders().cloned(),
+            ),
+            meta.row_groups().to_vec(),
+        )
+    }
+
+    #[test]
+    fn a_plan_covers_the_row_groups_rows_whatever_the_file_row_count_claims() {
+        for claimed in [200, 400] {
+            assert_eq!(
+                ReadPlan::from_selection(&claiming(claimed), vec![(300, false)], None, None)
+                    .unwrap()
+                    .row_groups(),
+                vec![0, 1, 2]
+            );
+
+            for selectors in [vec![(claimed as usize, false)], vec![(299, false)], vec![(301, false)]] {
+                assert!(matches!(
+                    ReadPlan::from_selection(&claiming(claimed), selectors, None, None),
+                    Err(Error::Plan(message)) if message.ends_with("cannot read a file of 300 rows")
+                ));
             }
-        );
+        }
     }
 
     fn with_lzo_names() -> ParquetMetaData {
@@ -446,32 +734,31 @@ mod tests {
         let column = |name: &str| Projected::resolve(&schema, name).unwrap();
 
         assert!(matches!(
-            unsupported_codec(&meta, &[0], &[column("id"), column("name")]),
+            unsupported_codec(&meta, &[0], &[column("id"), column("name")], &[]),
             Some(Error::Unsupported { column, parquet }) if column == "name" && parquet == "LZO"
         ));
-        assert!(unsupported_codec(&meta, &[0], &[column("id")]).is_none());
+        assert!(unsupported_codec(&meta, &[0], &[column("id")], &[]).is_none());
     }
 
     fn open(
         file: Vec<u8>,
         columns: &[&str],
-        offset: u64,
-        limit: Option<u64>,
+        selectors: Option<Vec<(usize, bool)>>,
     ) -> Result<(ParquetReader, Arc<Counting>), Error> {
         let footer = Footer::read(&Bytes::from(file.clone()))?;
         let source = Arc::new(Counting::new(file));
-        let size = source.data.len() as u64;
         let columns = columns.iter().map(|column| column.to_string()).collect::<Vec<_>>();
-        let plan = ReadPlan::new(footer.meta(), offset, limit);
+        let rows = footer.meta().file_metadata().num_rows() as usize;
+        let plan = ReadPlan::from_selection(footer.meta(), selectors.unwrap_or(vec![(rows, false)]), None, None)?;
 
         Ok((
-            ParquetReader::open(Arc::clone(&source), size, footer.meta(), &columns, plan, 1_024)?,
+            ParquetReader::open(Arc::clone(&source), footer.meta(), &columns, plan, 1_024)?,
             source,
         ))
     }
 
     fn read(file: Vec<u8>, columns: &[&str]) -> Result<Vec<ArrayRef>, Error> {
-        let (mut reader, _) = open(file, columns, 0, None)?;
+        let (mut reader, _) = open(file, columns, None)?;
         let (_, arrays) = reader.next().unwrap()?;
 
         assert!(reader.next().is_none());
@@ -620,7 +907,7 @@ mod tests {
 
     #[test]
     fn a_struct_path_is_named_as_asked() {
-        let (reader, _) = open(struct_file(), &["structure.name"], 0, None).unwrap();
+        let (reader, _) = open(struct_file(), &["structure.name"], None).unwrap();
 
         assert_eq!(reader.fields()[0].name(), "structure.name");
         assert!(reader.fields()[0].is_nullable());
@@ -644,6 +931,75 @@ mod tests {
         }
     }
 
+    /// `a >= 150` read for `b`, from `selectors`, `limit` rows at most.
+    fn filtered(selectors: Vec<(usize, bool)>, limit: Option<usize>) -> (Vec<i64>, Arc<Counting>) {
+        let file = four_groups();
+        let footer = Footer::read(&Bytes::from(file.clone())).unwrap();
+        let source = Arc::new(Counting::new(file));
+        let bytes = |value: &str| Raw::Bytes(value.as_bytes().to_vec());
+        let filter = Raw::Map(vec![
+            (b"leaf".to_vec(), bytes("intervals")),
+            (b"path".to_vec(), Raw::List(vec![bytes("a")])),
+            (
+                b"intervals".to_vec(),
+                Raw::List(vec![Raw::List(vec![
+                    Raw::Int(150),
+                    Raw::Bool(true),
+                    Raw::Null,
+                    Raw::Bool(false),
+                ])]),
+            ),
+        ]);
+        let plan = ReadPlan::from_selection(footer.meta(), selectors, Some(filter), limit).unwrap();
+        let mut reader =
+            ParquetReader::open(Arc::clone(&source), footer.meta(), &["b".to_string()], plan, 1_024).unwrap();
+        let mut values = Vec::new();
+
+        while let Some(batch) = reader.next() {
+            values.extend(
+                batch.unwrap().1[0]
+                    .as_primitive::<arrow_array::types::Int64Type>()
+                    .values()
+                    .iter(),
+            );
+        }
+
+        (values, source)
+    }
+
+    #[test]
+    fn a_row_filter_reads_only_the_matching_rows_of_the_unprojected_predicate_column() {
+        let (values, _) = filtered(vec![(400, false)], None);
+
+        assert_eq!(values, (150..400).collect::<Vec<_>>());
+    }
+
+    #[test]
+    fn a_row_filter_loads_the_offset_index_of_every_planned_group_and_skips_the_projection_of_a_group_it_empties() {
+        let (_, source) = filtered(vec![(400, false)], None);
+        let file = four_groups();
+
+        assert_eq!(
+            source.counted().1,
+            offset_index_bytes(&file, &[(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)])
+                + chunk_bytes(&file, &[0, 1, 2, 3], &[0])
+                + chunk_bytes(&file, &[1, 2, 3], &[1])
+        );
+    }
+
+    #[test]
+    fn a_limit_counts_the_rows_the_filter_keeps_and_no_page_of_the_next_group_is_fetched() {
+        let (values, limited) = filtered(vec![(400, false)], Some(60));
+        let (_, three_groups) = filtered(vec![(300, false), (100, true)], None);
+
+        assert_eq!(values, (150..210).collect::<Vec<_>>());
+        // the offset index of the last group is loaded with the plan, none of its pages
+        assert_eq!(
+            limited.counted().1,
+            three_groups.counted().1 + offset_index_bytes(&four_groups(), &[(3, 0), (3, 1)])
+        );
+    }
+
     /// Columns `a`, `b`, `c` (Int64) in four row groups of 100 rows.
     fn four_groups() -> Vec<u8> {
         let schema = Arc::new(Schema::new(vec![
@@ -695,7 +1051,7 @@ mod tests {
     #[test]
     fn a_full_read_fetches_each_row_group_once() {
         let file = four_groups();
-        let (reader, source) = open(file.clone(), &["a", "b", "c"], 0, None).unwrap();
+        let (reader, source) = open(file.clone(), &["a", "b", "c"], None).unwrap();
 
         assert_eq!(drained(reader), 400);
         assert_eq!(source.counted(), (4, chunk_bytes(&file, &[0, 1, 2, 3], &[0, 1, 2])));
@@ -704,39 +1060,173 @@ mod tests {
     #[test]
     fn a_projected_read_fetches_only_the_projected_chunks() {
         let file = four_groups();
-        let (reader, source) = open(file.clone(), &["b"], 0, None).unwrap();
+        let (reader, source) = open(file.clone(), &["b"], None).unwrap();
 
         assert_eq!(drained(reader), 400);
         assert_eq!(source.counted(), (4, chunk_bytes(&file, &[0, 1, 2, 3], &[1])));
     }
 
     #[test]
-    fn an_offset_read_fetches_only_the_planned_row_group_and_the_page_index() {
+    fn a_window_read_fetches_the_offset_index_and_the_projected_chunks_of_its_row_group() {
         let file = four_groups();
-        let (reader, source) = open(file.clone(), &["a", "c"], 250, Some(10)).unwrap();
-        let meta = Footer::read(&Bytes::from(file.clone())).unwrap();
-        let index = meta
-            .meta()
-            .row_groups()
+        let (reader, source) = open(
+            file.clone(),
+            &["a", "c"],
+            Some(vec![(250, true), (10, false), (140, true)]),
+        )
+        .unwrap();
+
+        assert_eq!(drained(reader), 10);
+        assert_eq!(
+            source.counted().1,
+            offset_index_bytes(&file, &[(2, 0), (2, 2)]) + chunk_bytes(&file, &[2], &[0, 2])
+        );
+    }
+
+    /// The bytes of the offset indexes of the given (group, leaf) chunks.
+    fn offset_index_bytes(file: &[u8], chunks: &[(usize, usize)]) -> usize {
+        let footer = Footer::read(&Bytes::from(file.to_vec())).unwrap();
+
+        chunks
             .iter()
-            .flat_map(|group| group.columns())
-            .map(|chunk| {
-                chunk.column_index_length().unwrap_or(0) as usize + chunk.offset_index_length().unwrap_or(0) as usize
+            .map(|(group, leaf)| {
+                footer
+                    .meta()
+                    .row_group(*group)
+                    .column(*leaf)
+                    .offset_index_length()
+                    .unwrap() as usize
             })
-            .sum::<usize>();
+            .sum()
+    }
 
-        assert_eq!(drained(reader), 10);
+    /// `s` (Utf8 "v{i % 5}", dictionary encoded) in groups of 100 rows, pages of 10 rows.
+    fn paged_groups(groups: usize) -> Vec<u8> {
+        let schema = Arc::new(Schema::new(vec![Field::new("s", DataType::Utf8, false)]));
+        let mut file = Vec::new();
+        let mut writer = ArrowWriter::try_new(
+            &mut file,
+            Arc::clone(&schema),
+            Some(
+                WriterProperties::builder()
+                    .set_max_row_group_row_count(Some(100))
+                    .set_data_page_row_count_limit(10)
+                    .set_write_batch_size(10)
+                    .build(),
+            ),
+        )
+        .unwrap();
+        writer
+            .write(
+                &RecordBatch::try_new(
+                    schema,
+                    vec![Arc::new(StringArray::from_iter_values(
+                        (0..groups * 100).map(|i| format!("v{}", i % 5)),
+                    ))],
+                )
+                .unwrap(),
+            )
+            .unwrap();
+        writer.close().unwrap();
+
+        file
+    }
+
+    /// Per (group, pages), the group's offset index, its dictionary page and those data pages.
+    fn page_bytes(file: &[u8], pages: &[(usize, &[usize])]) -> usize {
+        let meta = ParquetMetaDataReader::new()
+            .with_offset_index_policy(PageIndexPolicy::Required)
+            .parse_and_finish(&Bytes::from(file.to_vec()))
+            .unwrap();
+
+        offset_index_bytes(file, &pages.iter().map(|(group, _)| (*group, 0)).collect::<Vec<_>>())
+            + pages
+                .iter()
+                .map(|(group, pages)| {
+                    let locations = meta
+                        .page_index()
+                        .unwrap()
+                        .offset_index(*group, 0)
+                        .unwrap()
+                        .page_locations();
+                    let dictionary = locations[0].offset - meta.row_group(*group).column(0).byte_range().0 as i64;
+
+                    dictionary as usize
+                        + pages
+                            .iter()
+                            .map(|page| locations[*page].compressed_page_size as usize)
+                            .sum::<usize>()
+                })
+                .sum::<usize>()
+    }
 
-        let (reads, bytes) = source.counted();
+    fn strings(mut reader: ParquetReader) -> Vec<String> {
+        let mut values = Vec::new();
+
+        while let Some(batch) = reader.next() {
+            let (_, arrays) = batch.unwrap();
+            values.extend(
+                arrays[0]
+                    .as_binary::<i64>()
+                    .iter()
+                    .map(|value| String::from_utf8(value.unwrap().to_vec()).unwrap()),
+            );
+        }
+
+        values
+    }
+
+    #[test]
+    fn a_selection_inside_one_group_fetches_only_the_selected_pages_and_the_dictionary() {
+        let file = paged_groups(1);
+        let (reader, source) = open(file.clone(), &["s"], Some(vec![(35, true), (10, false), (55, true)])).unwrap();
+
+        assert_eq!(
+            strings(reader),
+            (35..45).map(|i| format!("v{}", i % 5)).collect::<Vec<_>>()
+        );
+        assert_eq!(source.counted().1, page_bytes(&file, &[(0, &[3, 4])]));
+    }
+
+    #[test]
+    fn a_selection_spanning_groups_fetches_the_selected_pages_of_each() {
+        let file = paged_groups(3);
+        let (reader, source) = open(file.clone(), &["s"], Some(vec![(95, true), (10, false), (195, true)])).unwrap();
+
+        assert_eq!(
+            strings(reader),
+            (95..105).map(|i| format!("v{}", i % 5)).collect::<Vec<_>>()
+        );
+        assert_eq!(source.counted().1, page_bytes(&file, &[(0, &[9]), (1, &[0])]));
+    }
+
+    #[test]
+    fn an_empty_selection_fetches_nothing() {
+        let file = paged_groups(3);
+        let (reader, source) = open(file, &["s"], Some(vec![(300, true)])).unwrap();
+
+        assert_eq!(drained(reader), 0);
+        assert_eq!(source.counted(), (0, 0));
+    }
+
+    #[test]
+    fn a_pruned_plan_fetches_only_the_kept_groups_chunks() {
+        let file = four_groups();
+        let (reader, source) = open(
+            file.clone(),
+            &["a", "b", "c"],
+            Some(vec![(100, true), (100, false), (100, true), (100, false)]),
+        )
+        .unwrap();
 
-        assert!(reads <= 3, "{reads} reads");
-        assert!(bytes >= chunk_bytes(&file, &[2], &[0, 2]), "{bytes} bytes");
-        assert!(bytes <= chunk_bytes(&file, &[2], &[0, 1, 2]) + index, "{bytes} bytes");
+        assert_eq!(drained(reader), 200);
+        assert_eq!(source.counted(), (2, chunk_bytes(&file, &[1, 3], &[0, 1, 2])));
     }
 
     #[test]
-    fn plan_past_the_end_reads_nothing() {
-        assert_eq!(plan(65_536, 10), (vec![], 0));
-        assert_eq!(plan(0, 0), (vec![], 0));
+    fn adjacent_ranges_are_coalesced() {
+        assert_eq!(coalesced(vec![10..20, 0..10, 30..40, 20..25]), vec![0..25, 30..40]);
+        assert_eq!(coalesced(vec![0..10, 5..8, 8..12]), vec![0..12]);
+        assert!(coalesced(vec![]).is_empty());
     }
 }
diff --git a/src/extension/arrow-ext/src/parquet/source.rs b/src/extension/arrow-ext/src/parquet/source.rs
index d0248331b3..9253aeca9c 100644
--- a/src/extension/arrow-ext/src/parquet/source.rs
+++ b/src/extension/arrow-ext/src/parquet/source.rs
@@ -132,7 +132,7 @@ impl ChunkReader for PhpSource {
 }
 
 /// Exactly `length` bytes at `start`, in one read.
-pub fn exact<R: ReadAt>(source: &R, start: u64, length: usize) -> Result<Bytes, ParquetError> {
+pub fn exact<R: ReadAt + ?Sized>(source: &R, start: u64, length: usize) -> Result<Bytes, ParquetError> {
     if length == 0 {
         return Ok(Bytes::new());
     }
diff --git a/src/extension/arrow-ext/src/parquet/write.rs b/src/extension/arrow-ext/src/parquet/write.rs
index 4eaf234486..3afb846742 100644
--- a/src/extension/arrow-ext/src/parquet/write.rs
+++ b/src/extension/arrow-ext/src/parquet/write.rs
@@ -3,12 +3,17 @@
 use std::sync::Arc;
 
 use arrow_array::{ArrayRef, RecordBatch, RecordBatchOptions};
-use arrow_schema::{Schema, SchemaRef};
-use parquet::arrow::ArrowWriter;
+use arrow_schema::{DataType, Field, Fields, Schema, SchemaRef};
+use parquet::arrow::arrow_writer::ArrowWriterOptions;
+use parquet::arrow::{ArrowSchemaConverter, ArrowWriter};
+use parquet::basic::{ConvertedType, LogicalType};
+use parquet::errors::ParquetError;
 use parquet::file::properties::WriterProperties;
+use parquet::schema::types::{BasicTypeInfo, SchemaDescriptor, Type};
 
 use crate::parquet::canonical::to_parquet;
 use crate::parquet::error::Error;
+use crate::parquet::options::ENUM_METADATA_KEY;
 use crate::parquet::sink::PhpSink;
 
 pub struct ParquetWriter {
@@ -17,13 +22,35 @@ pub struct ParquetWriter {
 }
 
 impl ParquetWriter {
+    /// Fields marked with `ENUM_METADATA_KEY` are written with the ENUM logical type; the marker itself is not.
     pub fn open(sink: PhpSink, schema: Schema, props: WriterProperties) -> Result<Self, Error> {
-        let schema = Arc::new(schema);
+        let converted = ArrowSchemaConverter::new()
+            .with_coerce_types(props.coerce_types())
+            .convert(&schema)?;
+        let Type::GroupType { basic_info, fields } = converted.root_schema() else {
+            unreachable!("the parquet schema root is a group");
+        };
+        let fields = fields
+            .iter()
+            .zip(schema.fields())
+            .map(|(parquet_type, field)| annotate_enums(parquet_type, field).map(Arc::new))
+            .collect::<Result<Vec<_>, _>>()?;
+        let root = Type::group_type_builder(basic_info.name())
+            .with_fields(fields)
+            .build()?;
+        let schema = Arc::new(Schema::new_with_metadata(
+            schema.fields().iter().map(|field| unmarked(field)).collect::<Vec<_>>(),
+            schema.metadata().clone(),
+        ));
+        let writer = ArrowWriter::try_new_with_options(
+            sink,
+            Arc::clone(&schema),
+            ArrowWriterOptions::new()
+                .with_properties(props)
+                .with_parquet_schema(SchemaDescriptor::new(Arc::new(root))),
+        )?;
 
-        Ok(Self {
-            writer: ArrowWriter::try_new(sink, Arc::clone(&schema), Some(props))?,
-            schema,
-        })
+        Ok(Self { writer, schema })
     }
 
     pub fn schema(&self) -> &SchemaRef {
@@ -53,3 +80,77 @@ impl ParquetWriter {
         Ok(())
     }
 }
+
+/// `parquet_type`: the type arrow-rs converts `field` to.
+fn annotate_enums(parquet_type: &Type, field: &Field) -> Result<Type, ParquetError> {
+    let Type::GroupType { basic_info, fields } = parquet_type else {
+        if !field.metadata().contains_key(ENUM_METADATA_KEY) {
+            return Ok(parquet_type.clone());
+        }
+
+        let basic_info = parquet_type.get_basic_info();
+
+        return Type::primitive_type_builder(basic_info.name(), parquet_type.get_physical_type())
+            .with_repetition(basic_info.repetition())
+            .with_logical_type(Some(LogicalType::Enum))
+            .with_converted_type(ConvertedType::ENUM)
+            .with_id(basic_info.has_id().then(|| basic_info.id()))
+            .build();
+    };
+    let fields = match field.data_type() {
+        DataType::Struct(children) => fields
+            .iter()
+            .zip(children)
+            .map(|(child_type, child)| annotate_enums(child_type, child))
+            .collect::<Result<Vec<_>, _>>()?,
+        DataType::Map(entries, _) => fields
+            .iter()
+            .map(|entries_type| annotate_enums(entries_type, entries))
+            .collect::<Result<Vec<_>, _>>()?,
+        // arrow-rs writes a list in three levels: the repeated group holds the element as a struct holds its child
+        DataType::List(element) => fields
+            .iter()
+            .map(|repeated| {
+                annotate_enums(
+                    repeated,
+                    &Field::new(
+                        repeated.name(),
+                        DataType::Struct(Fields::from(vec![Arc::clone(element)])),
+                        false,
+                    ),
+                )
+            })
+            .collect::<Result<Vec<_>, _>>()?,
+        _ => return Ok(parquet_type.clone()),
+    };
+
+    group(basic_info, fields)
+}
+
+fn group(basic_info: &BasicTypeInfo, fields: Vec<Type>) -> Result<Type, ParquetError> {
+    let builder = Type::group_type_builder(basic_info.name())
+        .with_fields(fields.into_iter().map(Arc::new).collect())
+        .with_logical_type(basic_info.logical_type_ref().cloned())
+        .with_converted_type(basic_info.converted_type())
+        .with_id(basic_info.has_id().then(|| basic_info.id()));
+
+    if basic_info.has_repetition() {
+        builder.with_repetition(basic_info.repetition()).build()
+    } else {
+        builder.build()
+    }
+}
+
+/// `field` without `ENUM_METADATA_KEY`, at any depth, so the embedded arrow schema stays as written before the marker.
+fn unmarked(field: &Field) -> Field {
+    let data_type = match field.data_type() {
+        DataType::List(element) => DataType::List(Arc::new(unmarked(element))),
+        DataType::Map(entries, sorted) => DataType::Map(Arc::new(unmarked(entries)), *sorted),
+        DataType::Struct(children) => DataType::Struct(children.iter().map(|child| unmarked(child)).collect()),
+        other => other.clone(),
+    };
+    let mut metadata = field.metadata().clone();
+    metadata.remove(ENUM_METADATA_KEY);
+
+    field.clone().with_data_type(data_type).with_metadata(metadata)
+}
diff --git a/src/extension/arrow-ext/src/php.rs b/src/extension/arrow-ext/src/php.rs
index f320eb8a90..43ec10fb2c 100644
--- a/src/extension/arrow-ext/src/php.rs
+++ b/src/extension/arrow-ext/src/php.rs
@@ -68,6 +68,13 @@ pub fn zval_str(bytes: &[u8]) -> Zval {
     zv
 }
 
+pub fn zval_array(table: ZBox<ZendHashTable>) -> Zval {
+    let mut zv = Zval::new();
+    zv.set_hashtable(table);
+
+    zv
+}
+
 pub fn zval_long(value: i64) -> Zval {
     let mut zv = Zval::new();
     zv.set_long(value);
@@ -247,10 +254,10 @@ const HASH_FLAG_PACKED: u8 = 1 << 2;
 
 /// Raw order-preserving iteration over packed and bucket layouts, binary-safe
 /// for arbitrary keys (ext-php-rs's `iter()` panics on non-UTF-8 string keys).
-pub fn ht_for_each<'a>(
+pub fn ht_for_each<'a, E>(
     ht: &'a ZendHashTable,
-    mut f: impl FnMut(Option<&'a ZendStr>, zend_ulong, &'a Zval) -> Result<(), PhpException>,
-) -> Result<(), PhpException> {
+    mut f: impl FnMut(Option<&'a ZendStr>, zend_ulong, &'a Zval) -> Result<(), E>,
+) -> Result<(), E> {
     let packed = unsafe { ht.u.v.flags } & HASH_FLAG_PACKED != 0;
 
     for index in 0..ht.nNumUsed {
diff --git a/src/extension/arrow-ext/src/render.rs b/src/extension/arrow-ext/src/render.rs
index 030ec2f9ed..9fd139861f 100644
--- a/src/extension/arrow-ext/src/render.rs
+++ b/src/extension/arrow-ext/src/render.rs
@@ -81,6 +81,8 @@ pub fn parquet_exception(error: Error, stream: &PhpStream, side: Side) -> PhpExc
             exception(INVALID_ARGUMENT, format!("Parquet file has no column \"{name}\""))
         }
         (Error::Options(message), _) => exception(INVALID_ARGUMENT, message),
+        (Error::Plan(message), _) => exception(INVALID_ARGUMENT, message),
+        (Error::Encrypted, _) => failure("arrow does not read encrypted Parquet files".to_string()),
         (Error::NotParquet(message), _) => exception(
             INVALID_ARGUMENT,
             format!("Given file is not valid Parquet file: {message}"),
diff --git a/src/extension/arrow-ext/src/thrift.rs b/src/extension/arrow-ext/src/thrift.rs
index b00d6d31ef..bceaa87550 100644
--- a/src/extension/arrow-ext/src/thrift.rs
+++ b/src/extension/arrow-ext/src/thrift.rs
@@ -3,6 +3,7 @@
 //! knowledge here.
 
 use std::collections::HashMap;
+use std::ops::Range;
 use std::rc::Rc;
 
 use ext_php_rs::exception::PhpException;
@@ -202,24 +203,125 @@ pub fn decode(bytes: &[u8], class: &str, field: Option<i16>) -> Result<Zval, Php
     }
 }
 
+/// Bytes that are not the compact protocol: what was wrong with them.
+#[derive(Debug, PartialEq, Eq)]
+pub struct Malformed(pub String);
+
+impl From<Malformed> for PhpException {
+    fn from(malformed: Malformed) -> Self {
+        ext_exception(format!("arrow failed to decode thrift: {}", malformed.0))
+    }
+}
+
+/// A struct field as it arrives: its id, its compact wire type and the byte range of its value.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Field {
+    pub id: i16,
+    wire: u8,
+    pub value: Range<usize>,
+}
+
+impl Field {
+    pub fn is_list(&self) -> bool {
+        self.wire == LIST
+    }
+}
+
+/// A struct's fields one at a time, nothing decoded; the first malformed field ends them.
+pub fn fields(bytes: &[u8]) -> Fields<'_> {
+    Fields {
+        reader: Reader { bytes, position: 0 },
+        last: 0,
+        done: false,
+    }
+}
+
+pub struct Fields<'a> {
+    reader: Reader<'a>,
+    last: i16,
+    done: bool,
+}
+
+impl Iterator for Fields<'_> {
+    type Item = Result<Field, Malformed>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.done {
+            return None;
+        }
+
+        let field = (|| {
+            let Some((id, wire)) = self.reader.field_header(&mut self.last)? else {
+                return Ok(None);
+            };
+            let start = self.reader.position;
+            self.reader.skip(wire, 0)?;
+
+            Ok(Some(Field {
+                id,
+                wire,
+                value: start..self.reader.position,
+            }))
+        })();
+
+        self.done = !matches!(field, Ok(Some(_)));
+
+        field.transpose()
+    }
+}
+
+/// The byte ranges of the list's elements one at a time, nothing decoded; the first malformed element ends them.
+pub fn elements(bytes: &[u8]) -> Result<Elements<'_>, Malformed> {
+    let mut reader = Reader { bytes, position: 0 };
+    let (remaining, element) = reader.list_header()?;
+
+    Ok(Elements {
+        reader,
+        remaining,
+        element,
+    })
+}
+
+pub struct Elements<'a> {
+    reader: Reader<'a>,
+    remaining: usize,
+    element: u8,
+}
+
+impl Iterator for Elements<'_> {
+    type Item = Result<Range<usize>, Malformed>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.remaining == 0 {
+            return None;
+        }
+
+        let start = self.reader.position;
+        let element = self.reader.skip_element(self.element, 1);
+        self.remaining = if element.is_ok() { self.remaining - 1 } else { 0 };
+
+        Some(element.map(|()| start..self.reader.position))
+    }
+}
+
 struct Reader<'a> {
     bytes: &'a [u8],
     position: usize,
 }
 
-fn truncated() -> PhpException {
-    ext_exception("arrow failed to decode thrift: the bytes end inside a value")
+fn truncated() -> Malformed {
+    Malformed("the bytes end inside a value".to_string())
 }
 
 impl Reader<'_> {
-    fn byte(&mut self) -> Result<u8, PhpException> {
+    fn byte(&mut self) -> Result<u8, Malformed> {
         let byte = *self.bytes.get(self.position).ok_or_else(truncated)?;
         self.position += 1;
 
         Ok(byte)
     }
 
-    fn take(&mut self, length: usize) -> Result<&[u8], PhpException> {
+    fn take(&mut self, length: usize) -> Result<&[u8], Malformed> {
         let end = self
             .position
             .checked_add(length)
@@ -231,7 +333,7 @@ impl Reader<'_> {
         Ok(taken)
     }
 
-    fn varint(&mut self) -> Result<u64, PhpException> {
+    fn varint(&mut self) -> Result<u64, Malformed> {
         let mut value = 0u64;
 
         for shift in (0..70).step_by(7) {
@@ -243,19 +345,17 @@ impl Reader<'_> {
             }
         }
 
-        Err(ext_exception(
-            "arrow failed to decode thrift: a varint longer than 10 bytes",
-        ))
+        Err(Malformed("a varint longer than 10 bytes".to_string()))
     }
 
-    fn zigzag(&mut self) -> Result<i64, PhpException> {
+    fn zigzag(&mut self) -> Result<i64, Malformed> {
         let value = self.varint()?;
 
         Ok((value >> 1) as i64 ^ -((value & 1) as i64))
     }
 
     /// The next field's id and compact type, `None` at the struct's STOP.
-    fn field_header(&mut self, last: &mut i16) -> Result<Option<(i16, u8)>, PhpException> {
+    fn field_header(&mut self, last: &mut i16) -> Result<Option<(i16, u8)>, Malformed> {
         let header = self.byte()?;
 
         if header == 0 {
@@ -264,7 +364,7 @@ impl Reader<'_> {
 
         let delta = header >> 4;
         *last = if delta == 0 {
-            i16::try_from(self.zigzag()?).map_err(|_| ext_exception("arrow failed to decode thrift: a field id"))?
+            i16::try_from(self.zigzag()?).map_err(|_| Malformed("a field id".to_string()))?
         } else {
             last.wrapping_add(i16::from(delta))
         };
@@ -273,7 +373,7 @@ impl Reader<'_> {
     }
 
     /// A list or set header: its size and element type.
-    fn list_header(&mut self) -> Result<(usize, u8), PhpException> {
+    fn list_header(&mut self) -> Result<(usize, u8), Malformed> {
         let header = self.byte()?;
         let size = match header >> 4 {
             15 => usize::try_from(self.varint()?).map_err(|_| truncated())?,
@@ -283,9 +383,9 @@ impl Reader<'_> {
         Ok((size, header & 0x0f))
     }
 
-    fn skip(&mut self, wire: u8, depth: usize) -> Result<(), PhpException> {
+    fn skip(&mut self, wire: u8, depth: usize) -> Result<(), Malformed> {
         if depth > DEPTH {
-            return Err(ext_exception("arrow failed to decode thrift: nested deeper than 64"));
+            return Err(Malformed("nested deeper than 64".to_string()));
         }
 
         match wire {
@@ -329,18 +429,14 @@ impl Reader<'_> {
                     self.skip(wire, depth + 1)?;
                 }
             }
-            other => {
-                return Err(ext_exception(format!(
-                    "arrow failed to decode thrift: compact type {other}"
-                )))
-            }
+            other => return Err(Malformed(format!("compact type {other}"))),
         }
 
         Ok(())
     }
 
     /// A container element: a bool is one byte there, not a field-header type.
-    fn skip_element(&mut self, wire: u8, depth: usize) -> Result<(), PhpException> {
+    fn skip_element(&mut self, wire: u8, depth: usize) -> Result<(), Malformed> {
         match wire {
             BOOLEAN_TRUE | BOOLEAN_FALSE => self.byte().map(|_| ()),
             wire => self.skip(wire, depth),
diff --git a/src/extension/arrow-ext/tests/phpt/045_parquet_lib_read_parity.phpt b/src/extension/arrow-ext/tests/phpt/045_parquet_lib_read_parity.phpt
index a7ce94a2ff..9e602e655f 100644
--- a/src/extension/arrow-ext/tests/phpt/045_parquet_lib_read_parity.phpt
+++ b/src/extension/arrow-ext/tests/phpt/045_parquet_lib_read_parity.phpt
@@ -86,8 +86,8 @@ EdgeCases/nonnullable.impala.parquet 100: identical
 EdgeCases/nonnullable.impala.parquet 10000: identical
 EdgeCases/null_list.parquet 100: identical
 EdgeCases/null_list.parquet 10000: identical
-EdgeCases/uint64_overflow.parquet 100: both refuse
-EdgeCases/uint64_overflow.parquet 10000: both refuse
+EdgeCases/uint64_overflow.parquet 100: identical
+EdgeCases/uint64_overflow.parquet 10000: identical
 EdgeCases/unsigned.parquet 100: identical
 EdgeCases/unsigned.parquet 10000: identical
 interval.parquet [id]: identical
diff --git a/src/extension/arrow-ext/tests/phpt/046_parquet_lib_write_parity.phpt b/src/extension/arrow-ext/tests/phpt/046_parquet_lib_write_parity.phpt
index a5da1e1e67..99dade1669 100644
--- a/src/extension/arrow-ext/tests/phpt/046_parquet_lib_write_parity.phpt
+++ b/src/extension/arrow-ext/tests/phpt/046_parquet_lib_write_parity.phpt
@@ -39,5 +39,5 @@ echo "{$cells} cells: {$accepted} accepted by both, {$refused} refused by both\n
 echo 'every type: ', arrow_outcome(static fn() => ParquetRows::read(MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(Writer::php(), EveryType::schema(), EveryType::rows())), 3)) === arrow_outcome(static fn() => ParquetRows::read(MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(new Writer(engine: new RustParquetEngine()), EveryType::schema(), EveryType::rows())), 3)) ? 'identical' : 'DIFFER', "\n";
 ?>
 --EXPECT--
-624 cells: 102 accepted by both, 522 refused by both
+624 cells: 104 accepted by both, 520 refused by both
 every type: identical
diff --git a/src/extension/arrow-ext/tests/phpt/047_parquet_footer_thrift_parity.phpt b/src/extension/arrow-ext/tests/phpt/047_parquet_footer_thrift_parity.phpt
index ee944b0629..2eeaf011ca 100644
--- a/src/extension/arrow-ext/tests/phpt/047_parquet_footer_thrift_parity.phpt
+++ b/src/extension/arrow-ext/tests/phpt/047_parquet_footer_thrift_parity.phpt
@@ -35,8 +35,8 @@ foreach ([...glob($fixtures . '/*.parquet'), ...glob($fixtures . '/EdgeCases/*.p
     printf(
         "%s: thrift %s, schema %s, footer reads %d\n",
         substr($path, strlen($fixtures) + 1),
-        serialize($file->thrift()) === serialize($php) ? 'identical' : 'DIFFER',
-        serialize($file->schema()) === serialize(Schema::fromThrift($php->schema)) ? 'identical' : 'DIFFER',
+        serialize($file->footer()->thrift()) === serialize($php) ? 'identical' : 'DIFFER',
+        serialize($file->footer()->schema()) === serialize(Schema::fromThrift($php->schema)) ? 'identical' : 'DIFFER',
         $reads,
     );
     $file->close();
@@ -57,8 +57,8 @@ $file = new RustParquetFileReader(new MemorySourceStream($units));
 
 printf(
     "temporal units: thrift %s, schema %s\n",
-    serialize($file->thrift()) === serialize($php) ? 'identical' : 'DIFFER',
-    serialize($file->schema()) === serialize(Schema::fromThrift($php->schema)) ? 'identical' : 'DIFFER',
+    serialize($file->footer()->thrift()) === serialize($php) ? 'identical' : 'DIFFER',
+    serialize($file->footer()->schema()) === serialize(Schema::fromThrift($php->schema)) ? 'identical' : 'DIFFER',
 );
 $file->close();
 ?>
diff --git a/src/extension/arrow-ext/tests/phpt/048_parquet_lib_no_leaks.phpt b/src/extension/arrow-ext/tests/phpt/048_parquet_lib_no_leaks.phpt
index d59a7583b7..6565447436 100644
--- a/src/extension/arrow-ext/tests/phpt/048_parquet_lib_no_leaks.phpt
+++ b/src/extension/arrow-ext/tests/phpt/048_parquet_lib_no_leaks.phpt
@@ -39,18 +39,18 @@ $cycle = static function () use ($schema, $options, $rows, $columns): void {
     $writer->close();
 
     $file = new RustParquetFileReader($filesystem->readFrom(path('memory://leaks.parquet')));
-    $file->thrift();
-    $file->schema();
-    $file->metadata();
+    $file->footer()->thrift();
+    $file->footer()->schema();
+    $file->footer()->metadata();
 
-    foreach (new RustColumnsReader($file, $columns, 2, 1, 3) as $chunk) {
+    foreach (new RustColumnsReader($file, $columns, 2, arrow_read_plan($file, 1, 3)) as $chunk) {
     }
 
-    foreach ($file->readColumns($columns, 2, 3, 1) as $chunk) {
+    foreach ($file->readColumns($columns, 2, arrow_read_plan($file, 1, 3)) as $chunk) {
     }
 
     try {
-        new RustColumnsReader($file, ['missing'], 2, null, null);
+        new RustColumnsReader($file, ['missing'], 2, arrow_read_plan($file));
         throw new LogicException('a missing column was read');
     } catch (Flow\Parquet\Exception\InvalidArgumentException) {
     }
diff --git a/src/extension/arrow-ext/tests/phpt/050_parquet_batch_roundtrip.phpt b/src/extension/arrow-ext/tests/phpt/050_parquet_batch_roundtrip.phpt
index 95aa5e661f..d44b79b476 100644
--- a/src/extension/arrow-ext/tests/phpt/050_parquet_batch_roundtrip.phpt
+++ b/src/extension/arrow-ext/tests/phpt/050_parquet_batch_roundtrip.phpt
@@ -41,7 +41,8 @@ $roundTrip = static function (Filesystem $filesystem) use ($source, $target, $op
     $writer->writeRows($rows);
     $writer->close();
 
-    $batches = new RustBatchReader(new RustParquetFileReader($filesystem->readFrom(path('memory://source.parquet'))), ['id', 'name', 'tags'], 100, null, null);
+    $source = new RustParquetFileReader($filesystem->readFrom(path('memory://source.parquet')));
+    $batches = new RustBatchReader($source, ['id', 'name', 'tags'], 100, arrow_read_plan($source));
     $schema = $batches->schema();
     $copy = new RustParquetFileWriter($filesystem->writeTo(path('memory://copy.parquet')), SchemaConverter::toExtension($target), Compressions::SNAPPY, $options, 100);
     $counts = [];
@@ -64,7 +65,8 @@ echo get_class($schema), ' ', $schema->arrowSchemaAddress() > 0 ? 'has an addres
 echo 'batches: ', implode(',', $counts), "\n";
 echo 'round trip: ', iterator_to_array(Reader::php()->readStream($filesystem->readFrom(path('memory://copy.parquet')))->values(), false) === $expected ? 'identical' : 'DIFFER', "\n";
 
-$batches = new RustBatchReader(new RustParquetFileReader($filesystem->readFrom(path('memory://source.parquet'))), ['id', 'name', 'tags'], 100, null, null);
+$source = new RustParquetFileReader($filesystem->readFrom(path('memory://source.parquet')));
+$batches = new RustBatchReader($source, ['id', 'name', 'tags'], 100, arrow_read_plan($source));
 $batch = $batches->next();
 $twice = new RustParquetFileWriter($filesystem->writeTo(path('memory://twice.parquet')), SchemaConverter::toExtension($target), Compressions::SNAPPY, $options, 100);
 $twice->writeArrowBatch($batch);
diff --git a/src/extension/arrow-ext/tests/phpt/052_parquet_file_reader_writer_contracts.phpt b/src/extension/arrow-ext/tests/phpt/052_parquet_file_reader_writer_contracts.phpt
index 35320738f6..5ef565484b 100644
--- a/src/extension/arrow-ext/tests/phpt/052_parquet_file_reader_writer_contracts.phpt
+++ b/src/extension/arrow-ext/tests/phpt/052_parquet_file_reader_writer_contracts.phpt
@@ -36,17 +36,18 @@ $open = static fn(string $name, bool $int96AsDatetime = true): RustParquetFileRe
 
 echo "-- reader\n";
 $file = $open('structs.parquet');
-$metadata = $file->metadata();
+$footer = $file->footer();
+$metadata = $footer->metadata();
 $bytes = array_sum(array_map(static fn($group): int => $group->totalByteSize(), $metadata->rowGroups()->all()));
-var_dump($file instanceof ParquetFileReader);
+var_dump($file instanceof ParquetFileReader, $footer instanceof Flow\Parquet\ParquetFile\Footer, $file->footer() === $footer);
 var_dump(serialize($metadata) === serialize(Reader::php()->read("{$fixtures}/structs.parquet")->metadata()));
-var_dump(serialize($open('structs.parquet')->schema()) === serialize($metadata->schema()), $file->schema() === $metadata->schema());
-var_dump($file->rowsNumber() === $metadata->rowsNumber(), $file->totalByteSize() === $bytes);
+var_dump(serialize($open('structs.parquet')->footer()->schema()) === serialize($metadata->schema()), $footer->schema() === $metadata->schema());
+var_dump($footer->rowsNumber() === $metadata->rowsNumber(), $footer->totalByteSize() === $bytes);
 
-$chunks = $file->readColumns(['struct_flat', 'struct_flat.int'], 30, 70, 5);
+$chunks = $file->readColumns(['struct_flat', 'struct_flat.int'], 30, arrow_read_plan($file, 5, 70));
 $php = (new PhpParquetEngine(ByteOrder::LITTLE_ENDIAN, new Options()))
     ->openForRead(NativeLocalSourceStream::open(path_real("{$fixtures}/structs.parquet")))
-    ->readColumns(['struct_flat', 'struct_flat.int'], 30, 70, 5);
+    ->readColumns(['struct_flat', 'struct_flat.int'], 30, arrow_read_plan($file, 5, 70));
 var_dump($chunks instanceof Iterator);
 $read = [];
 
@@ -57,25 +58,27 @@ foreach ($chunks as $key => $chunk) {
 echo json_encode(array_map(static fn(array $chunk): int => count($chunk['struct_flat.int']), $read)), "\n";
 var_dump($read == iterator_to_array($php));
 echo arrow_outcome(static fn() => $chunks->rewind()), "\n";
-echo arrow_outcome(static fn() => iterator_to_array($open('EdgeCases/int96.parquet', false)->readColumns(['ts'], 10, null, null))), "\n";
-var_dump(count(iterator_to_array($open('EdgeCases/int96.parquet')->readColumns(['ts'], 10, null, null))) > 0);
-echo arrow_outcome(static fn() => $open('lists.parquet')->readColumns(['list.list.element'], 10, null, null)), "\n";
+$int96 = $open('EdgeCases/int96.parquet', false);
+echo arrow_outcome(static fn() => iterator_to_array($int96->readColumns(['ts'], 10, arrow_read_plan($int96)))), "\n";
+$int96 = $open('EdgeCases/int96.parquet');
+var_dump(count(iterator_to_array($int96->readColumns(['ts'], 10, arrow_read_plan($int96)))) > 0);
+$lists = $open('lists.parquet');
+echo arrow_outcome(static fn() => $lists->readColumns(['list.list.element'], 10, arrow_read_plan($lists))), "\n";
 echo arrow_outcome(static fn() => new RustParquetFileReader(new MemorySourceStream('{"not": "parquet"}'))), "\n";
 
+$plan = arrow_read_plan($file);
 $file->close();
 
 foreach ([
-    static fn() => $file->metadata(),
-    static fn() => $file->schema(),
-    static fn() => $file->rowsNumber(),
-    static fn() => $file->totalByteSize(),
-    static fn() => $file->thrift(),
-    static fn() => $file->readColumns(['struct_flat'], 1, null, null),
+    static fn() => $file->footer(),
+    static fn() => $file->readColumns(['struct_flat'], 1, $plan),
     static fn() => $file->close(),
 ] as $call) {
     echo arrow_outcome($call), "\n";
 }
 
+var_dump($footer->rowsNumber() === $metadata->rowsNumber());
+
 echo "-- writer\n";
 $filesystem = memory_filesystem();
 $schema = Schema::with(FlatColumn::int32('id'), FlatColumn::string('name'));
@@ -169,6 +172,8 @@ bool(true)
 bool(true)
 bool(true)
 bool(true)
+bool(true)
+bool(true)
 [30,30,10]
 bool(true)
 Flow\Parquet\Exception\RuntimeException: RustColumnsReader cannot rewind
@@ -179,10 +184,7 @@ Flow\Parquet\Exception\InvalidArgumentException: Given file is not valid Parquet
 Flow\Parquet\Exception\RuntimeException: Reader is not open
 Flow\Parquet\Exception\RuntimeException: Reader is not open
 Flow\Parquet\Exception\RuntimeException: Reader is not open
-Flow\Parquet\Exception\RuntimeException: Reader is not open
-Flow\Parquet\Exception\RuntimeException: Reader is not open
-Flow\Parquet\Exception\RuntimeException: Reader is not open
-Flow\Parquet\Exception\RuntimeException: Reader is not open
+bool(true)
 -- writer
 bool(true)
 Flow\Parquet\Exception\ValidationException: Column "id" row 1: expected int, got string
diff --git a/src/extension/arrow-ext/tests/phpt/053_columns_reader_refusal_ends.phpt b/src/extension/arrow-ext/tests/phpt/053_columns_reader_refusal_ends.phpt
index 100fc339a7..2e1b401eb4 100644
--- a/src/extension/arrow-ext/tests/phpt/053_columns_reader_refusal_ends.phpt
+++ b/src/extension/arrow-ext/tests/phpt/053_columns_reader_refusal_ends.phpt
@@ -28,7 +28,7 @@ $writer->close();
 
 $bytes = $filesystem->readFrom(path('memory://groups.parquet'))->content();
 $open = static fn(string $bytes): RustParquetFileReader => new RustParquetFileReader(new StringSourceStream(path('memory://groups.parquet'), $bytes));
-$chunk = $open($bytes)->metadata()->rowGroups()->all()[1]->columnChunks()[0];
+$chunk = $open($bytes)->footer()->metadata()->rowGroups()->all()[1]->columnChunks()[0];
 $corrupt = substr_replace($bytes, str_repeat("\xFF", $chunk->totalCompressedSize()), $chunk->pageOffset(), $chunk->totalCompressedSize());
 
 $step = static function (string $label, callable $call): void {
@@ -41,7 +41,8 @@ $step = static function (string $label, callable $call): void {
     echo $label, ': ', $result, "\n";
 };
 
-$reader = new RustColumnsReader($open($corrupt), ['id'], 2, null, null);
+$corrupted = $open($corrupt);
+$reader = new RustColumnsReader($corrupted, ['id'], 2, arrow_read_plan($corrupted));
 $step('key before rewind', static fn() => $reader->key());
 $step('current', static fn() => $reader->current());
 $step('rewind', static fn() => $reader->rewind());
@@ -54,7 +55,8 @@ $step('rewind', static fn() => $reader->rewind());
 
 // refused before the first chunk: rewind() throws once, then the reader is empty and rewinds freely
 $corrupt = substr_replace($bytes, str_repeat("\xFF", 8), 4, 8);
-$reader = new RustColumnsReader($open($corrupt), ['id'], 2, null, null);
+$corrupted = $open($corrupt);
+$reader = new RustColumnsReader($corrupted, ['id'], 2, arrow_read_plan($corrupted));
 $step('rewind (chunk refused)', static fn() => $reader->rewind());
 $step('valid', static fn() => $reader->valid());
 $step('rewind', static fn() => $reader->rewind());
diff --git a/src/extension/arrow-ext/tests/phpt/054_abi_matches_flow_php_parquet.phpt b/src/extension/arrow-ext/tests/phpt/054_abi_matches_flow_php_parquet.phpt
index a9dd504db2..5596066c9a 100644
--- a/src/extension/arrow-ext/tests/phpt/054_abi_matches_flow_php_parquet.phpt
+++ b/src/extension/arrow-ext/tests/phpt/054_abi_matches_flow_php_parquet.phpt
@@ -17,7 +17,7 @@ use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 
 use function Flow\Filesystem\DSL\path;
 
-var_dump(FLOW_ARROW_ABI === ArrowExtension::ABI);
+var_dump(FLOW_ARROW_ABI === ArrowExtension::ABI, FLOW_ARROW_ABI);
 var_dump(ArrowExtension::detect()->available());
 
 $writer = (new AdaptiveParquetEngine())->openForWrite(
@@ -31,5 +31,6 @@ $writer->close();
 ?>
 --EXPECT--
 bool(true)
+int(2)
 bool(true)
 bool(true)
diff --git a/src/extension/arrow-ext/tests/phpt/055_read_plan_converter.phpt b/src/extension/arrow-ext/tests/phpt/055_read_plan_converter.phpt
new file mode 100644
index 0000000000..9e9ab6182b
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/055_read_plan_converter.phpt
@@ -0,0 +1,62 @@
+--TEST--
+arrow reads a plan through ReadPlanConverter::toExtension(), called by name: file-absolute (row count, skip) selectors, the row filter tree and the limit counted after it
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Arrow\Parquet\RustColumnsReader;
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\Engine\Arrow\ReadPlanConverter;
+use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Options;
+use Flow\Parquet\Reader\{ReadPlan, RowSelection, RowSelector};
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+$selection = new RowSelection(new RowSelector(1, true), new RowSelector(2, false), new RowSelector(2, true), new RowSelector(1, false));
+$plan = new ReadPlan($selection, $selection, new InMemoryIndexes());
+
+var_dump(is_callable([ReadPlanConverter::class, 'toExtension']));
+echo json_encode(ReadPlanConverter::toExtension($plan)), "\n";
+
+$file = new RustParquetFileReader(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
+$ids = [];
+
+foreach (new RustColumnsReader($file, ['id'], 10, $plan) as $chunk) {
+    array_push($ids, ...$chunk['id']);
+}
+
+echo json_encode($ids), "\n";
+
+echo arrow_outcome(static fn() => new RustColumnsReader($file, ['id'], 10, ReadPlan::window(5, new InMemoryIndexes()))), "\n";
+
+$filter = BoundFilter::bind(
+    new All(parquet_column('id')->in([2, 3, 6]), parquet_column('id')->isNull()->negate(), parquet_column('missing')->isNull()),
+    $file->footer()->schema(),
+    new Options(),
+);
+$filtered = new ReadPlan(RowSelection::all(6), RowSelection::none(6), new InMemoryIndexes(), $filter, 2);
+
+echo json_encode(ReadPlanConverter::toExtension($filtered)), "\n";
+
+$ids = [];
+
+foreach (new RustColumnsReader($file, ['id'], 10, $filtered) as $chunk) {
+    array_push($ids, ...$chunk['id']);
+}
+
+echo json_encode($ids), "\n";
+?>
+--EXPECT--
+bool(true)
+{"selectors":[[1,true],[2,false],[2,true],[1,false]],"limit":null}
+[2,3,6]
+Flow\Parquet\Exception\InvalidArgumentException: A read plan over 5 rows cannot read a file of 6 rows
+{"selectors":[[6,false]],"filter":{"and":[{"leaf":"intervals","path":["id"],"intervals":[[2,true,2,true],[3,true,3,true],[6,true,6,true]]},{"not":{"leaf":"is_null","path":["id"]}},{"leaf":"absent","is_null":true}]},"limit":2}
+[2,3]
diff --git a/src/extension/arrow-ext/tests/phpt/056_row_group_chunks.phpt b/src/extension/arrow-ext/tests/phpt/056_row_group_chunks.phpt
new file mode 100644
index 0000000000..d8d2b5ce09
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/056_row_group_chunks.phpt
@@ -0,0 +1,62 @@
+--TEST--
+arrow slices the asked leaves' column chunks and orders from the footer for RustRowGroupChunks::fromThrift(), called by name: the statistics the PHP engine decodes from the same file
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\Engine\Arrow\RustRowGroupChunks;
+use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+
+$bytes = MemoryParquetFile::threeRowGroups();
+$phpFile = MemoryParquetFile::read(Reader::php(), $bytes);
+$php = $phpFile->reader()->footer();
+$id = $php->schema()->getFlat('id');
+$tag = $php->schema()->getFlat('tags.list.element');
+
+var_dump(is_callable([RustRowGroupChunks::class, 'fromThrift']));
+
+$rust = (new RustParquetFileReader(new MemorySourceStream($bytes)))->footer()->rowGroupChunks([$id, $tag]);
+$expected = $php->rowGroupChunks([$id, $tag]);
+
+$rowGroups = $php->metadata()->rowGroups()->all();
+$groups = count($rowGroups);
+
+echo get_class($rust), ' ', $groups, "\n";
+
+for ($group = 0; $group < $groups; $group++) {
+    foreach ([$id, $tag] as $column) {
+        $statistics = $rust->chunk($group, $column)->statistics();
+        printf(
+            "%d %s: %d rows, %s..%s, %s\n",
+            $group,
+            $column->flatPath(),
+            $rowGroups[$group]->rowsCount(),
+            var_export($statistics?->minValue($column), true),
+            var_export($statistics?->maxValue($column), true),
+            $rust->chunk($group, $column) == $expected->chunk($group, $column) ? 'as PHP decodes it' : 'NOT as PHP decodes it',
+        );
+    }
+}
+
+var_dump($rust->columnOrder($id) === $expected->columnOrder($id));
+echo arrow_outcome(static fn() => (new RustParquetFileReader(new MemorySourceStream($bytes)))->footer()->rowGroupChunks([FlatColumn::int64('missing')])), "\n";
+echo arrow_outcome(static fn() => (new RustParquetFileReader(new MemorySourceStream($bytes)))->footer()->rowGroupChunks([FlatColumn::int64('tags')])), "\n";
+?>
+--EXPECT--
+bool(true)
+Flow\Parquet\Engine\Arrow\RustRowGroupChunks 3
+0 id: 2 rows, 1..2, as PHP decodes it
+0 tags.list.element: 2 rows, 't1'..'t2', as PHP decodes it
+1 id: 2 rows, 3..4, as PHP decodes it
+1 tags.list.element: 2 rows, 't3'..'t4', as PHP decodes it
+2 id: 2 rows, 5..6, as PHP decodes it
+2 tags.list.element: 2 rows, 't5'..'t6', as PHP decodes it
+bool(true)
+Flow\Parquet\Exception\InvalidArgumentException: Parquet file has no leaf column "missing"
+Flow\Parquet\Exception\InvalidArgumentException: Parquet file has no leaf column "tags"
diff --git a/src/extension/arrow-ext/tests/phpt/057_parquet_statistics_options.phpt b/src/extension/arrow-ext/tests/phpt/057_parquet_statistics_options.phpt
new file mode 100644
index 0000000000..9cf3e252ee
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/057_parquet_statistics_options.phpt
@@ -0,0 +1,83 @@
+--TEST--
+STATISTICS_TRUNCATE_LENGTH reaches the arrow writer: a long string's column chunk statistics are truncated to it and marked inexact; both engines refuse 0 and negatives alike. STATISTICS_LEVEL, COLUMN_INDEX_TRUNCATE_LENGTH and PAGE_HEADER_STATISTICS reach it too
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Writer;
+use Flow\Parquet\Writer\StatisticsLevel;
+
+$column = FlatColumn::string('s');
+
+foreach ([null, 8] as $length) {
+    $options = $length === null ? new Options() : (new Options())->set(Option::STATISTICS_TRUNCATE_LENGTH, $length);
+    $bytes = MemoryParquetFile::written(
+        new Writer(options: $options, engine: new RustParquetEngine()),
+        Schema::with($column),
+        [['s' => str_repeat('a', 101)]],
+    );
+    $statistics = MemoryParquetFile::read(Reader::php(), $bytes)->metadata()->columnChunks()[0]->statistics();
+
+    echo $length ?? 'default', ': ',
+        $statistics->minValue($column), ' ', $statistics->maxValue($column), ' ',
+        var_export($statistics->isMinValueExact(), true), ' ', var_export($statistics->isMaxValueExact(), true), "\n";
+}
+foreach ([0, -1] as $length) {
+    foreach (['php' => Writer::php(options: (new Options())->set(Option::STATISTICS_TRUNCATE_LENGTH, $length)), 'arrow' => new Writer(options: (new Options())->set(Option::STATISTICS_TRUNCATE_LENGTH, $length), engine: new RustParquetEngine())] as $engine => $writer) {
+        echo $engine, ' ', $length, ': ', arrow_outcome(static fn() => MemoryParquetFile::written($writer, Schema::with($column), [['s' => 'a']])), "\n";
+    }
+}
+foreach (StatisticsLevel::cases() as $level) {
+    $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+        new Writer(options: (new Options())->set(Option::STATISTICS_LEVEL, $level), engine: new RustParquetEngine()),
+        Schema::with($column),
+        [['s' => 'a']],
+    ));
+
+    echo $level->name, ': chunk ', var_export($file->metadata()->columnChunks()[0]->statistics() !== null, true),
+        ', column index ', var_export($file->indexes()->columnIndex(0, $column) !== null, true),
+        ', offset index ', var_export($file->indexes()->offsetIndex(0, $column) !== null, true), "\n";
+}
+$index = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+    new Writer(options: (new Options())->set(Option::COLUMN_INDEX_TRUNCATE_LENGTH, 8), engine: new RustParquetEngine()),
+    Schema::with($column),
+    [['s' => str_repeat('a', 101)]],
+))->indexes()->columnIndex(0, $column);
+echo 'column index 8: ', $index->minValues[0], ' ', $index->maxValues[0], "\n";
+foreach (['php' => Writer::php(options: (new Options())->set(Option::COLUMN_INDEX_TRUNCATE_LENGTH, 0)), 'arrow' => new Writer(options: (new Options())->set(Option::COLUMN_INDEX_TRUNCATE_LENGTH, 0), engine: new RustParquetEngine())] as $engine => $writer) {
+    echo $engine, ' column index 0: ', arrow_outcome(static fn() => MemoryParquetFile::written($writer, Schema::with($column), [['s' => 'a']])), "\n";
+}
+foreach ([false, true] as $enabled) {
+    $headers = iterator_to_array(MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+        new Writer(options: (new Options())->set(Option::PAGE_HEADER_STATISTICS, $enabled), engine: new RustParquetEngine()),
+        Schema::with($column),
+        [['s' => 'a']],
+    ))->pageHeaders(), false);
+
+    echo 'page header statistics ', var_export($enabled, true), ': ',
+        var_export(end($headers)->pageHeader->dataPageHeader()?->statistics()?->maxValue($column), true), "\n";
+}
+--EXPECT--
+default: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab false false
+8: aaaaaaaa aaaaaaab false false
+php 0: Flow\Parquet\Exception\InvalidArgumentException: STATISTICS_TRUNCATE_LENGTH must be greater than 0, 0 given
+arrow 0: Flow\Parquet\Exception\InvalidArgumentException: STATISTICS_TRUNCATE_LENGTH must be greater than 0, 0 given
+php -1: Flow\Parquet\Exception\InvalidArgumentException: STATISTICS_TRUNCATE_LENGTH must be greater than 0, -1 given
+arrow -1: Flow\Parquet\Exception\InvalidArgumentException: STATISTICS_TRUNCATE_LENGTH must be greater than 0, -1 given
+CHUNK: chunk true, column index false, offset index true
+NONE: chunk false, column index false, offset index true
+PAGE: chunk true, column index true, offset index true
+column index 8: aaaaaaaa aaaaaaab
+php column index 0: Flow\Parquet\Exception\InvalidArgumentException: COLUMN_INDEX_TRUNCATE_LENGTH must be greater than 0, 0 given
+arrow column index 0: Flow\Parquet\Exception\InvalidArgumentException: COLUMN_INDEX_TRUNCATE_LENGTH must be greater than 0, 0 given
+page header statistics false: NULL
+page header statistics true: 'a'
diff --git a/src/extension/arrow-ext/tests/phpt/058_parquet_encrypted_refused.phpt b/src/extension/arrow-ext/tests/phpt/058_parquet_encrypted_refused.phpt
new file mode 100644
index 0000000000..e76fb22e46
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/058_parquet_encrypted_refused.phpt
@@ -0,0 +1,29 @@
+--TEST--
+arrow refuses Parquet modular encryption when the file is opened: an encrypted footer, and a plaintext footer holding an encrypted column chunk
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Thrift\{CompactProtocol, MemoryBuffer};
+use Flow\Parquet\ThriftModel\{ColumnCryptoMetaData, EncryptionWithFooterKey, FileMetaData};
+
+echo arrow_outcome(static fn() => new RustParquetFileReader(new MemorySourceStream("PAR1\0\0\0\0\4\0\0\0PARE"))), "\n";
+
+$bytes = MemoryParquetFile::threeRowGroups();
+$length = unpack('V', substr($bytes, -8, 4))[1];
+$footer = new FileMetaData();
+$footer->read(new CompactProtocol(new MemoryBuffer(substr($bytes, -8 - $length, $length))));
+$footer->row_groups[1]->columns[0]->crypto_metadata = new ColumnCryptoMetaData(['ENCRYPTION_WITH_FOOTER_KEY' => new EncryptionWithFooterKey()]);
+$footer->write(new CompactProtocol($encrypted = new MemoryBuffer()));
+$file = substr($bytes, 0, -8 - $length) . $encrypted->data() . pack('V', strlen($encrypted->data())) . 'PAR1';
+
+echo arrow_outcome(static fn() => new RustParquetFileReader(new MemorySourceStream($file))), "\n";
+?>
+--EXPECT--
+Flow\Parquet\Exception\RuntimeException: arrow does not read encrypted Parquet files
+Flow\Parquet\Exception\RuntimeException: arrow does not read encrypted Parquet files
diff --git a/src/extension/arrow-ext/tests/phpt/059_parquet_malformed_read_plan.phpt b/src/extension/arrow-ext/tests/phpt/059_parquet_malformed_read_plan.phpt
new file mode 100644
index 0000000000..d95eeddec8
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/059_parquet_malformed_read_plan.phpt
@@ -0,0 +1,64 @@
+--TEST--
+arrow refuses, as one InvalidArgumentException, a read plan ReadPlanConverter::toExtension() did not shape as (row count, skip) selectors, a limit and a row filter tree
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+namespace Flow\Parquet\Engine\Arrow;
+
+// declared before the autoloader sees it: stands in for the lib's converter
+final class ReadPlanConverter
+{
+    public static mixed $converted = null;
+
+    public static function toExtension(mixed $plan): mixed
+    {
+        return self::$converted;
+    }
+}
+
+namespace Test;
+
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Arrow\Parquet\RustColumnsReader;
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\Engine\Arrow\ReadPlanConverter;
+use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+
+$file = new RustParquetFileReader(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
+
+foreach ([
+    null,
+    [],
+    ['selectors' => 'all'],
+    ['selectors' => [6]],
+    ['selectors' => [[-1, false]]],
+    ['selectors' => [[6, 'no']]],
+    ['selectors' => [[6]]],
+    ['selectors' => [[6, false]]],
+    ['selectors' => [[6, false]], 'limit' => -1],
+    ['selectors' => [[6, false]], 'limit' => null, 'filter' => ['leaf' => 'absent']],
+    ['selectors' => [[6, false]], 'limit' => null, 'filter' => ['xor' => []]],
+    ['selectors' => [[6, false]], 'limit' => null, 'filter' => ['leaf' => 'intervals', 'path' => ['id'], 'intervals' => [['1', true, null, false]]]],
+] as $converted) {
+    ReadPlanConverter::$converted = $converted;
+    echo json_encode($converted), ' => ', arrow_outcome(static fn() => new RustColumnsReader($file, ['id'], 10, ReadPlan::window(6, new InMemoryIndexes()))), "\n";
+}
+?>
+--EXPECT--
+null => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: not an array
+[] => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: no 'selectors' list
+{"selectors":"all"} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: no 'selectors' list
+{"selectors":[6]} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: a selector is not an array
+{"selectors":[[-1,false]]} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: a selector's row count is not an int of 0 or more
+{"selectors":[[6,"no"]]} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: a selector's skip is not a bool
+{"selectors":[[6]]} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: a selector's skip is not a bool
+{"selectors":[[6,false]]} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: no 'limit'
+{"selectors":[[6,false]],"limit":-1} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed read plan: 'limit' is not an int of 0 or more
+{"selectors":[[6,false]],"limit":null,"filter":{"leaf":"absent"}} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed row filter: missing key "is_null"
+{"selectors":[[6,false]],"limit":null,"filter":{"xor":[]}} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed row filter: missing key "leaf"
+{"selectors":[[6,false]],"limit":null,"filter":{"leaf":"intervals","path":["id"],"intervals":[["1",true,null,false]]}} => Flow\Parquet\Exception\InvalidArgumentException: arrow received a malformed row filter: bounds of "id" are not Int64 values
diff --git a/src/extension/arrow-ext/tests/phpt/060_parquet_page_selection.phpt b/src/extension/arrow-ext/tests/phpt/060_parquet_page_selection.phpt
new file mode 100644
index 0000000000..61bf313e39
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/060_parquet_page_selection.phpt
@@ -0,0 +1,50 @@
+--TEST--
+arrow reads a page-pruned, row-filtered plan over a parquet-mr file whose columns break pages at other rows (int64 at 0, 200, 428, 628, 828; float at 0, 300, 628, 928): exactly the matching rows, the same as the PHP engine
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Options;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\ReadPlanner;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+$path = __DIR__ . '/../../../../lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/Fixtures/delta_binary_acked_encoded_integers.parquet';
+$columns = ['int32_column', 'int64_column', 'float_column'];
+
+foreach ([parquet_column('int64_column')->lessThan(300), parquet_column('float_column')->lessThan(400.0)] as $filter) {
+    $php = Reader::php()->read($path);
+    $plan = (new ReadPlanner())->plan(
+        $php->reader()->footer(),
+        $php->indexes(),
+        BoundFilter::bind($filter, $php->schema(), new Options()),
+    );
+    $read = static function (Reader $reader) use ($path, $columns, $plan): array {
+        $rows = [];
+        $file = $reader->read($path);
+
+        foreach ($file->reader()->readColumns($columns, 100, $plan) as $chunk) {
+            foreach (array_keys($chunk['int32_column']) as $index) {
+                $rows[] = array_map(static fn(string $column): mixed => $chunk[$column][$index], $columns);
+            }
+        }
+
+        return $rows;
+    };
+    $arrow = $read(new Reader(engine: new RustParquetEngine()));
+
+    echo json_encode(array_map(
+        static fn($selector): array => [$selector->rowCount, $selector->skip],
+        $plan->selection->selectors(),
+    )), ' ', count($arrow), ' ', var_export($arrow === $read(Reader::php()), true), "\n";
+}
+
+?>
+--EXPECT--
+[[428,false],[572,true]] 270 true
+[[628,false],[372,true]] 342 true
diff --git a/src/extension/arrow-ext/tests/phpt/061_map_entries_named_key_value.phpt b/src/extension/arrow-ext/tests/phpt/061_map_entries_named_key_value.phpt
new file mode 100644
index 0000000000..8128a21a3e
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/061_map_entries_named_key_value.phpt
@@ -0,0 +1,32 @@
+--TEST--
+The arrow writer names a map's repeated group key_value (parquet-format LogicalTypes.md), the leaf paths the PHP writer writes
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\MapKey;
+use Flow\Parquet\ParquetFile\Schema\MapValue;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Context\ParquetRows;
+use Flow\Parquet\Writer;
+
+$schema = Schema::with(NestedColumn::map('m', MapKey::string(), MapValue::int64()));
+$rows = [['m' => ['a' => 1, 'b' => 2]]];
+
+foreach (['arrow' => new Writer(engine: new RustParquetEngine()), 'php' => Writer::php()] as $name => $writer) {
+    $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written($writer, $schema, $rows));
+
+    echo $name, ': ', implode(', ', array_map(
+        static fn($column): string => $column->flatPath(),
+        $file->metadata()->schema()->columnsFlat(),
+    )), ' ', json_encode(ParquetRows::read($file, 10)), "\n";
+}
+--EXPECT--
+arrow: m.key_value.key, m.key_value.value [{"m":{"a":1,"b":2}}]
+php: m.key_value.key, m.key_value.value [{"m":{"a":1,"b":2}}]
diff --git a/src/extension/arrow-ext/tests/phpt/062_parquet_uint64_strings.phpt b/src/extension/arrow-ext/tests/phpt/062_parquet_uint64_strings.phpt
new file mode 100644
index 0000000000..a702bcd4c1
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/062_parquet_uint64_strings.phpt
@@ -0,0 +1,36 @@
+--TEST--
+UINT_64 reads as its decimal string and writes from an int >= 0 or a digit string; a negative int is refused naming its row
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Context\ParquetRows;
+use Flow\Parquet\Writer;
+
+$fixture = __DIR__ . '/../../../../lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/uint64_duckdb.parquet';
+$arrow = new Reader(engine: new RustParquetEngine());
+$schema = Schema::with(new FlatColumn('u', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)));
+$writer = static fn(): Writer => new Writer(engine: new RustParquetEngine());
+
+echo json_encode(ParquetRows::read($arrow->read($fixture), 10)), "\n";
+echo json_encode(ParquetRows::read(MemoryParquetFile::read($arrow, MemoryParquetFile::written(
+    $writer(),
+    $schema,
+    [['u' => '18446744073709551615'], ['u' => 7], ['u' => null], ['u' => '9223372036854775808']],
+)), 10)), "\n";
+echo arrow_outcome(static fn() => MemoryParquetFile::written($writer(), $schema, [['u' => 1], ['u' => -1]])), "\n";
+echo arrow_outcome(static fn() => MemoryParquetFile::written($writer(), $schema, [['u' => '18446744073709551616']])), "\n";
+--EXPECT--
+[{"col0":"0"},{"col0":"9223372036854775808"},{"col0":"18446744073709551615"}]
+[{"u":"18446744073709551615"},{"u":"7"},{"u":null},{"u":"9223372036854775808"}]
+Flow\Parquet\Exception\ValidationException: Column "u" row 1: expected int >= 0 or digit string, got int
+Flow\Parquet\Exception\ValidationException: Column "u" row 0: expected int >= 0 or digit string, got string
diff --git a/src/extension/arrow-ext/tests/phpt/063_parquet_bloom_filter_options.phpt b/src/extension/arrow-ext/tests/phpt/063_parquet_bloom_filter_options.phpt
new file mode 100644
index 0000000000..d528c0b896
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/063_parquet_bloom_filter_options.phpt
@@ -0,0 +1,51 @@
+--TEST--
+COLUMNS_BLOOM_FILTERS reaches the arrow writer: the columns asked get a bloom filter, located in PHP metadata and holding the written values; a column not asked gets none, and a digit-only path (an int array key) is not skipped
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Writer;
+
+$id = FlatColumn::int64('id');
+$name = FlatColumn::string('name');
+$options = (new Options())->set(Option::COLUMNS_BLOOM_FILTERS, [
+    'id' => new BloomFilterOptions(0.01, 100),
+    'name' => new BloomFilterOptions(),
+    '2024' => new BloomFilterOptions(),
+]);
+$file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+    new Writer(options: $options, engine: new RustParquetEngine()),
+    Schema::with($id, $name, $year = FlatColumn::int64('2024'), $other = FlatColumn::int64('other')),
+    [['id' => 7, 'name' => 'ann', '2024' => 5, 'other' => 1], ['id' => 9, 'name' => 'bob', '2024' => 6, 'other' => 2]],
+));
+
+foreach ($file->metadata()->columnChunks() as $chunk) {
+    echo $chunk->flatPath(), ': ', $chunk->bloomFilterOffset() === null ? 'no bloom filter' : 'bloom filter', "\n";
+}
+
+$hash = new BloomHash();
+echo 'id 7: ', var_export($file->indexes()->bloomFilter(0, $id)?->check($hash->of($id, 7)), true), "\n";
+echo 'name bob: ', var_export($file->indexes()->bloomFilter(0, $name)?->check($hash->of($name, 'bob')), true), "\n";
+echo '2024 6: ', var_export($file->indexes()->bloomFilter(0, $year)?->check($hash->of($year, 6)), true), "\n";
+echo 'other: ', var_export($file->indexes()->bloomFilter(0, $other), true), "\n";
+?>
+--EXPECT--
+id: bloom filter
+name: bloom filter
+2024: bloom filter
+other: no bloom filter
+id 7: true
+name bob: true
+2024 6: true
+other: NULL
diff --git a/src/extension/arrow-ext/tests/phpt/064_parquet_row_filter.phpt b/src/extension/arrow-ext/tests/phpt/064_parquet_row_filter.phpt
new file mode 100644
index 0000000000..bfd777e33e
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/064_parquet_row_filter.phpt
@@ -0,0 +1,51 @@
+--TEST--
+arrow reads exactly the rows a mixed row filter keeps from the filter parity fixture, as the PHP engine does: nulls, NaN, -0.0, a struct leaf, a decimal, a timestamp; an unbound conjunct is left to the caller
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Options;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\ReadPlanner;
+use Flow\Parquet\Tests\Context\FilterRows;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+$bytes = FilterRows::bytes('row_groups_arrow');
+
+foreach ([
+    new All(parquet_column('score')->lessThan(30.0)->negate(), parquet_column('maybe')->isNull()->or(parquet_column('address.city')->equals('c3')), parquet_column('label')->equals(10)),
+    new All(parquet_column('score')->equals(0.0), parquet_column('amount')->greaterThan(20.25)->negate(), parquet_column('ts')->greaterThanOrEqual(new DateTimeImmutable('2024-01-01 00:00:00 UTC'))),
+    parquet_column('missing')->isNull()->and(parquet_column('id')->lessThan(3)),
+] as $filter) {
+    $php = MemoryParquetFile::read(Reader::php(), $bytes);
+    $plan = (new ReadPlanner())->plan(
+        $php->reader()->footer(),
+        $php->indexes(),
+        BoundFilter::bind($filter, $php->schema(), new Options()),
+    );
+    $ids = static function (Reader $reader) use ($bytes, $plan): array {
+        $ids = [];
+        $file = MemoryParquetFile::read($reader, $bytes);
+
+        foreach ($file->reader()->readColumns(['id'], 7, $plan) as $chunk) {
+            array_push($ids, ...$chunk['id']);
+        }
+
+        return $ids;
+    };
+    $arrow = $ids(new Reader(engine: new RustParquetEngine()));
+
+    echo json_encode($arrow), ' ', var_export($arrow === $ids(Reader::php()), true), "\n";
+}
+?>
+--EXPECT--
+[11,31,32,33,34,36,37,38,39] true
+[0,10] true
+[0,1,2] true
diff --git a/src/extension/arrow-ext/tests/phpt/065_parquet_column_option_keys.phpt b/src/extension/arrow-ext/tests/phpt/065_parquet_column_option_keys.phpt
new file mode 100644
index 0000000000..31324259bb
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/065_parquet_column_option_keys.phpt
@@ -0,0 +1,85 @@
+--TEST--
+COLUMNS_COMPRESSIONS, COLUMNS_ENCODINGS and COLUMNS_BLOOM_FILTERS reach the arrow writer by column path: a digit-only path (an int array key) applies to its column, a dictionary encoding enables the column's dictionary as the PHP writer writes it, a key that is not UTF-8 or a value that is not a string is refused instead of crashing
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Filesystem\Stream\StringDestinationStream;
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\Engine\Arrow\SchemaConverter;
+use Flow\Parquet\Engine\RustParquetFileWriter;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Writer;
+
+use function Flow\Filesystem\DSL\path;
+
+$write = static fn(Option $option, array $columns): string => MemoryParquetFile::written(
+    new Writer(
+        // a dictionary page of one byte falls back to the column encoding at once
+        options: (new Options())->set($option, $columns)->set(Option::DICTIONARY_PAGE_SIZE, 1),
+        engine: new RustParquetEngine(),
+    ),
+    Schema::with(FlatColumn::int64('2024'), FlatColumn::int64('other')),
+    [['2024' => 1, 'other' => 2], ['2024' => 3, 'other' => 4]],
+);
+
+foreach (MemoryParquetFile::read(Reader::php(), $write(Option::COLUMNS_COMPRESSIONS, ['2024' => Compressions::GZIP]))->metadata()->columnChunks() as $chunk) {
+    echo $chunk->flatPath(), ': ', $chunk->codec()->name, "\n";
+}
+
+foreach (MemoryParquetFile::read(Reader::php(), $write(Option::COLUMNS_ENCODINGS, ['2024' => Encodings::DELTA_BINARY_PACKED]))->metadata()->columnChunks() as $chunk) {
+    echo $chunk->flatPath(), ': ', in_array(Encodings::DELTA_BINARY_PACKED, $chunk->encodings(), true) ? 'DELTA_BINARY_PACKED' : 'default encoding', "\n";
+}
+
+foreach (['php' => static fn(Options $options): Writer => Writer::php(options: $options), 'arrow' => static fn(Options $options): Writer => new Writer(options: $options, engine: new RustParquetEngine())] as $engine => $writer) {
+    $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+        $writer((new Options())->set(Option::COLUMNS_ENCODINGS, ['word' => Encodings::RLE_DICTIONARY])),
+        Schema::with(FlatColumn::string('word')),
+        [['word' => 'a'], ['word' => 'b'], ['word' => 'a']],
+    ));
+
+    foreach ($file->pageHeaders() as $page) {
+        echo $engine, ': ', $page->pageHeader->type()->name, ' ', $page->pageHeader->encoding()->name, "\n";
+    }
+}
+
+foreach (MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+    new Writer(options: (new Options())->set(Option::COLUMNS_ENCODINGS, ['word' => Encodings::PLAIN_DICTIONARY]), engine: new RustParquetEngine()),
+    Schema::with(FlatColumn::string('word')),
+    [['word' => 'a']],
+))->pageHeaders() as $page) {
+    echo 'arrow PLAIN_DICTIONARY: ', $page->pageHeader->type()->name, ' ', $page->pageHeader->encoding()->name, "\n";
+}
+
+echo arrow_outcome(static fn() => new RustParquetFileWriter(new StringDestinationStream(path('memory://file.parquet')), SchemaConverter::toExtension(Schema::with(FlatColumn::int64('id'))), Compressions::SNAPPY, ['COLUMNS_COMPRESSIONS' => ['id' => 1]], 100)), "\n";
+echo arrow_outcome(static fn() => new RustParquetFileWriter(new StringDestinationStream(path('memory://file.parquet')), SchemaConverter::toExtension(Schema::with(FlatColumn::int64('id'))), Compressions::SNAPPY, ['COLUMNS_ENCODINGS' => ['id' => null]], 100)), "\n";
+echo arrow_outcome(static fn() => $write(Option::COLUMNS_COMPRESSIONS, ["\xFF" => Compressions::GZIP])), "\n";
+echo arrow_outcome(static fn() => $write(Option::COLUMNS_ENCODINGS, ["\xFF" => Encodings::PLAIN])), "\n";
+echo arrow_outcome(static fn() => $write(Option::COLUMNS_BLOOM_FILTERS, ["\xFF" => new BloomFilterOptions()])), "\n";
+?>
+--EXPECT--
+2024: GZIP
+other: SNAPPY
+2024: DELTA_BINARY_PACKED
+other: default encoding
+php: DICTIONARY_PAGE PLAIN
+php: DATA_PAGE RLE_DICTIONARY
+arrow: DICTIONARY_PAGE PLAIN
+arrow: DATA_PAGE RLE_DICTIONARY
+arrow PLAIN_DICTIONARY: DICTIONARY_PAGE PLAIN
+arrow PLAIN_DICTIONARY: DATA_PAGE RLE_DICTIONARY
+Flow\Parquet\Exception\InvalidArgumentException: COLUMNS_COMPRESSIONS['id'] must be a string
+Flow\Parquet\Exception\InvalidArgumentException: COLUMNS_ENCODINGS['id'] must be a string
+Flow\Parquet\Exception\InvalidArgumentException: COLUMNS_COMPRESSIONS has a key that is not a column path
+Flow\Parquet\Exception\InvalidArgumentException: COLUMNS_ENCODINGS has a key that is not a column path
+Flow\Parquet\Exception\InvalidArgumentException: COLUMNS_BLOOM_FILTERS has a key that is not a column path
diff --git a/src/extension/arrow-ext/tests/phpt/066_parquet_page_maximum_rows_count.phpt b/src/extension/arrow-ext/tests/phpt/066_parquet_page_maximum_rows_count.phpt
new file mode 100644
index 0000000000..71fe376a39
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/066_parquet_page_maximum_rows_count.phpt
@@ -0,0 +1,47 @@
+--TEST--
+PAGE_MAXIMUM_ROWS_COUNT reaches the arrow writer: its pages close at that many rows, as the PHP writer's do, whatever ARROW_WRITE_BATCH_SIZE; both engines refuse 0 and negatives alike
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Writer;
+
+$id = FlatColumn::int64('id');
+// a null makes arrow-rs write in mini-batches of write_batch_size rows, not of the page row limit
+$rows = array_map(static fn(int $id): array => ['id' => $id % 4 === 0 ? null : $id], range(1, 10));
+$options = (new Options())
+    ->set(Option::PAGE_MAXIMUM_ROWS_COUNT, 3)
+    ->set(Option::PAGE_SIZE_CHECK_INTERVAL, 1);
+
+foreach (['php' => Writer::php(options: $options), 'arrow' => new Writer(options: $options, engine: new RustParquetEngine())] as $engine => $writer) {
+    $offsetIndex = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written($writer, Schema::with($id), $rows))
+        ->indexes()
+        ->offsetIndex(0, $id);
+
+    echo $engine, ': ', implode(',', array_map(static fn(PageLocation $page): int => $page->firstRowIndex, $offsetIndex->pages)), "\n";
+}
+foreach ([0, -1] as $maximum) {
+    $options = (new Options())->set(Option::PAGE_MAXIMUM_ROWS_COUNT, $maximum);
+
+    foreach (['php' => Writer::php(options: $options), 'arrow' => new Writer(options: $options, engine: new RustParquetEngine())] as $engine => $writer) {
+        echo $engine, ' ', $maximum, ': ', arrow_outcome(static fn() => MemoryParquetFile::written($writer, Schema::with($id), [['id' => 1]])), "\n";
+    }
+}
+?>
+--EXPECT--
+php: 0,3,6,9
+arrow: 0,3,6,9
+php 0: Flow\Parquet\Exception\InvalidArgumentException: PAGE_MAXIMUM_ROWS_COUNT must be greater than 0, 0 given
+arrow 0: Flow\Parquet\Exception\InvalidArgumentException: PAGE_MAXIMUM_ROWS_COUNT must be greater than 0, 0 given
+php -1: Flow\Parquet\Exception\InvalidArgumentException: PAGE_MAXIMUM_ROWS_COUNT must be greater than 0, -1 given
+arrow -1: Flow\Parquet\Exception\InvalidArgumentException: PAGE_MAXIMUM_ROWS_COUNT must be greater than 0, -1 given
diff --git a/src/extension/arrow-ext/tests/phpt/067_parquet_row_group_size_bytes.phpt b/src/extension/arrow-ext/tests/phpt/067_parquet_row_group_size_bytes.phpt
new file mode 100644
index 0000000000..a4d6843201
--- /dev/null
+++ b/src/extension/arrow-ext/tests/phpt/067_parquet_row_group_size_bytes.phpt
@@ -0,0 +1,29 @@
+--TEST--
+ROW_GROUP_SIZE_BYTES below 1 is refused by both engines alike
+--SKIPIF--
+<?php if (!extension_loaded("arrow")) die("skip arrow extension not loaded"); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Writer;
+
+foreach ([0, -1] as $bytes) {
+    $options = (new Options())->set(Option::ROW_GROUP_SIZE_BYTES, $bytes);
+
+    foreach (['php' => Writer::php(options: $options), 'arrow' => new Writer(options: $options, engine: new RustParquetEngine())] as $engine => $writer) {
+        echo $engine, ' ', $bytes, ': ', arrow_outcome(static fn() => MemoryParquetFile::written($writer, Schema::with(FlatColumn::int64('id')), [['id' => 1]])), "\n";
+    }
+}
+?>
+--EXPECT--
+php 0: Flow\Parquet\Exception\InvalidArgumentException: ROW_GROUP_SIZE_BYTES must be greater than 0, 0 given
+arrow 0: Flow\Parquet\Exception\InvalidArgumentException: ROW_GROUP_SIZE_BYTES must be greater than 0, 0 given
+php -1: Flow\Parquet\Exception\InvalidArgumentException: ROW_GROUP_SIZE_BYTES must be greater than 0, -1 given
+arrow -1: Flow\Parquet\Exception\InvalidArgumentException: ROW_GROUP_SIZE_BYTES must be greater than 0, -1 given
diff --git a/src/extension/arrow-ext/tests/phpt/bootstrap.php b/src/extension/arrow-ext/tests/phpt/bootstrap.php
index 000169488f..c110fc648d 100644
--- a/src/extension/arrow-ext/tests/phpt/bootstrap.php
+++ b/src/extension/arrow-ext/tests/phpt/bootstrap.php
@@ -62,3 +62,19 @@ function arrow_interfaces_reflection(): string
 
     return (string) json_encode($interfaces);
 }
+
+/**
+ * The plan of the rows [`$offset`, `$offset + $limit`) of `$file`, as `ReadPlanner::plan()` builds it without a filter.
+ */
+function arrow_read_plan(
+    Flow\Parquet\ParquetFileReader $file,
+    int $offset = 0,
+    ?int $limit = null,
+): Flow\Parquet\Reader\ReadPlan {
+    return Flow\Parquet\Reader\ReadPlan::window(
+        $file->footer()->rowsNumber(),
+        new Flow\Parquet\Tests\Double\InMemoryIndexes(),
+        $offset,
+        $limit,
+    );
+}
diff --git a/src/extension/flow-php-ext/php/Flow/ETL/Adapter/Parquet/RustParquetOpenSource.php b/src/extension/flow-php-ext/php/Flow/ETL/Adapter/Parquet/RustParquetOpenSource.php
index c7593c4384..3786de7a62 100644
--- a/src/extension/flow-php-ext/php/Flow/ETL/Adapter/Parquet/RustParquetOpenSource.php
+++ b/src/extension/flow-php-ext/php/Flow/ETL/Adapter/Parquet/RustParquetOpenSource.php
@@ -9,6 +9,7 @@
 use Flow\ETL\RustIterator;
 use Flow\ETL\Schema;
 use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
 use RuntimeException;
 
 use function extension_loaded;
@@ -30,7 +31,7 @@ public function __construct(RustParquetFileReader $file)
      *
      * @return RustIterator<Rows>
      */
-    public function batches(Schema $schema, int $batchSize, ?int $offset, ?int $limit, Backend $backend): RustIterator
+    public function batches(Schema $schema, int $batchSize, ReadPlan $plan, Backend $backend): RustIterator
     {
         throw new RuntimeException('flow_php extension is not loaded');
     }
diff --git a/src/extension/flow-php-ext/src/interfaces.rs b/src/extension/flow-php-ext/src/interfaces.rs
index d98a248442..55a9b30042 100644
--- a/src/extension/flow-php-ext/src/interfaces.rs
+++ b/src/extension/flow-php-ext/src/interfaces.rs
@@ -20,6 +20,7 @@ const ROWS: DataType = DataType::object("Flow\\ETL\\Rows");
 const SCHEMA: DataType = DataType::object("Flow\\ETL\\Schema");
 const BACKEND: DataType = DataType::object("Flow\\ETL\\Column\\Backend");
 const ITERATOR: DataType = DataType::object("Iterator");
+const READ_PLAN: DataType = DataType::object("Flow\\Parquet\\Reader\\ReadPlan");
 const COLUMN_TYPES: DataType = DataType::object("Flow\\ETL\\Schema\\Inference\\ColumnTypes");
 const SCHEMA_INFERENCE: DataType = DataType::object("Flow\\ETL\\Schema\\Inference\\SchemaInference");
 const TYPE_NARROWER: DataType = DataType::object("Flow\\Types\\Type\\TypeNarrower");
@@ -318,8 +319,7 @@ pub fn register() -> Result<()> {
                 vec![
                     Arg::new("schema", SCHEMA),
                     Arg::new("batchSize", DataType::Long),
-                    Arg::new("offset", DataType::Long).allow_null(),
-                    Arg::new("limit", DataType::Long).allow_null(),
+                    Arg::new("plan", READ_PLAN),
                     Arg::new("backend", BACKEND),
                 ],
                 ITERATOR,
diff --git a/src/extension/flow-php-ext/src/lib.rs b/src/extension/flow-php-ext/src/lib.rs
index 345286df8b..a648e28aed 100644
--- a/src/extension/flow-php-ext/src/lib.rs
+++ b/src/extension/flow-php-ext/src/lib.rs
@@ -30,7 +30,7 @@ use ext_php_rs::{info_table_end, info_table_row, info_table_start};
 
 /// The contract version flow-php/etl expects (`Flow\ETL\FlowPhpExtension::ABI`); both change together whenever a
 /// registered class or interface changes.
-const FLOW_PHP_ABI: i64 = 1;
+const FLOW_PHP_ABI: i64 = 2;
 
 pub extern "C" fn php_module_info(_module: *mut ModuleEntry) {
     info_table_start!();
diff --git a/src/extension/flow-php-ext/src/parquet/etl.rs b/src/extension/flow-php-ext/src/parquet/etl.rs
index 2f3999b1a4..8c6e870e67 100644
--- a/src/extension/flow-php-ext/src/parquet/etl.rs
+++ b/src/extension/flow-php-ext/src/parquet/etl.rs
@@ -14,9 +14,7 @@ use crate::arrow_c;
 use crate::backend::{adopt_batch, native_column};
 use crate::batch_columns::HeldBatch;
 use crate::column::RustColumn;
-use crate::ctx::{
-    call_method, column_key, construct, find_class, ht_for_each, ht_insert, null_zval, zval_long, zval_str,
-};
+use crate::ctx::{call_method, column_key, construct, find_class, ht_for_each, ht_insert, zval_long, zval_str};
 use crate::exception::ext_exception;
 use crate::interfaces::{parquet_open_sink_ce, parquet_open_source_ce};
 use crate::iterator::RustIterator;
@@ -99,16 +97,9 @@ impl RustParquetOpenSource {
         })
     }
 
-    /// Batches of at most `$batchSize` rows of `$schema`'s columns, every column adopted by `$backend`; the file's
-    /// schema is checked before any batch.
-    pub fn batches(
-        &self,
-        schema: &Zval,
-        batchSize: i64,
-        offset: Option<i64>,
-        limit: Option<i64>,
-        backend: &Zval,
-    ) -> PhpResult<RustIterator> {
+    /// Batches of at most `$batchSize` rows of `$schema`'s columns, the rows `$plan` selects, every column adopted by
+    /// `$backend`; the file's schema is checked before any batch.
+    pub fn batches(&self, schema: &Zval, batchSize: i64, plan: &Zval, backend: &Zval) -> PhpResult<RustIterator> {
         let mut columns = Vec::new();
         let mut names = ZendHashTable::new();
 
@@ -119,7 +110,6 @@ impl RustParquetOpenSource {
 
         let mut names_zv = Zval::new();
         names_zv.set_hashtable(names);
-        let optional = |value: Option<i64>| value.map_or_else(null_zval, zval_long);
 
         self.close()?;
 
@@ -129,8 +119,7 @@ impl RustParquetOpenSource {
                 self.file.shallow_clone(),
                 names_zv,
                 zval_long(batchSize),
-                optional(offset),
-                optional(limit),
+                plan.shallow_clone(),
             ],
         )?
         .into_zval(false)?;
diff --git a/src/extension/flow-php-ext/tests/phpt/068_parquet_read_parity.phpt b/src/extension/flow-php-ext/tests/phpt/068_parquet_read_parity.phpt
index 201e440f11..a3230682ba 100644
--- a/src/extension/flow-php-ext/tests/phpt/068_parquet_read_parity.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/068_parquet_read_parity.phpt
@@ -38,8 +38,6 @@ foreach ([...glob($fixtures . '/*.parquet'), ...glob($fixtures . '/EdgeCases/*.p
                 $filesystem->readFrom(path($file)),
                 (new SchemaConverter())->toFlow((new Reader(engine: new PhpParquetEngine()))->read($file)->schema()),
                 $batchSize,
-                null,
-                null,
             );
             $rows = [];
 
@@ -66,22 +64,16 @@ echo outcome(static fn() => rust_parquet_batches(
     $filesystem->readFrom(path($emptylist)),
     schema(list_schema('emptylist', type_list(type_integer()))),
     100,
-    null,
-    null,
 )), "\n";
 echo outcome(static fn() => rust_parquet_batches(
     $filesystem->readFrom(path($fixtures . '/multiple_pages.parquet')),
     schema(str_schema('int64')),
     100,
-    null,
-    null,
 )), "\n";
 echo outcome(static fn() => rust_parquet_batches(
     $filesystem->readFrom(path($fixtures . '/multiple_pages.parquet')),
     schema(str_schema('missing')),
     100,
-    null,
-    null,
 )), "\n";
 ?>
 --EXPECT--
@@ -117,8 +109,8 @@ EdgeCases/nonnullable.impala.parquet 100: identical
 EdgeCases/nonnullable.impala.parquet 10000: identical
 EdgeCases/null_list.parquet 100: both refuse
 EdgeCases/null_list.parquet 10000: both refuse
-EdgeCases/uint64_overflow.parquet 100: both refuse
-EdgeCases/uint64_overflow.parquet 10000: both refuse
+EdgeCases/uint64_overflow.parquet 100: identical
+EdgeCases/uint64_overflow.parquet 10000: identical
 EdgeCases/unsigned.parquet 100: identical
 EdgeCases/unsigned.parquet 10000: identical
 Flow\ETL\Exception\InvalidArgumentException: Parquet column "emptylist" (List(Null)) is read as List(Null), its schema type list<integer> stores List(Int64)
diff --git a/src/extension/flow-php-ext/tests/phpt/069_parquet_offset_limit.phpt b/src/extension/flow-php-ext/tests/phpt/069_parquet_offset_limit.phpt
index 2aec1da3ea..6216e4ef51 100644
--- a/src/extension/flow-php-ext/tests/phpt/069_parquet_offset_limit.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/069_parquet_offset_limit.phpt
@@ -1,5 +1,5 @@
 --TEST--
-RustParquetOpenSource reads offset/limit windows of an 8-row-group file, and refuses a batch size, offset or limit out of range
+RustParquetOpenSource reads the planned windows of an 8-row-group file, and refuses a batch size out of range or a plan over other rows
 --SKIPIF--
 <?php if (!extension_loaded("flow_php")) die("skip flow_php extension not loaded"); ?>
 <?php extension_loaded('arrow') || die('skip arrow'); ?>
@@ -7,15 +7,18 @@ RustParquetOpenSource reads offset/limit windows of an 8-row-group file, and ref
 <?php
 require __DIR__ . '/bootstrap.php';
 
-use Flow\Parquet\Engine\RustParquetFileWriter;
+use Flow\ETL\Column\RustBackend;
+use Flow\Parquet\Engine\{RustParquetFileReader, RustParquetFileWriter};
 
-use Flow\ETL\Adapter\Parquet\{RustParquetOpenSink, SchemaConverter};
+use Flow\ETL\Adapter\Parquet\{RustParquetOpenSink, RustParquetOpenSource, SchemaConverter};
 use Flow\Parquet\Engine\Arrow\{OptionsConverter, SchemaConverter as ArrowSchemaConverter};
 use Flow\Parquet\{Option, Options, Reader};
 use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\Reader\ReadPlan;
 
 use function Flow\ETL\DSL\{array_to_rows, int_schema, schema};
 use function Flow\Filesystem\DSL\{memory_filesystem, path};
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
 
 $filesystem = memory_filesystem();
 $schema = schema(int_schema('id'));
@@ -50,9 +53,11 @@ foreach ([[0, 10], [5399, 3], [20000, 15000], [65000, 100], [65046, 1], [65536,
     var_dump($ids === ($ids === [] ? [] : range($offset, $offset + count($ids) - 1)));
 }
 
-foreach ([[0, null, null], [-1, null, null], [10, -1, null], [10, null, -1]] as [$batchSize, $offset, $limit]) {
-    echo outcome(static fn() => rust_parquet_batches($filesystem->readFrom(path('memory://groups.parquet')), $schema, $batchSize, $offset, $limit)), "\n";
+foreach ([0, -1] as $batchSize) {
+    echo outcome(static fn() => rust_parquet_batches($filesystem->readFrom(path('memory://groups.parquet')), $schema, $batchSize)), "\n";
 }
+
+echo outcome(static fn() => (new RustParquetOpenSource(new RustParquetFileReader($filesystem->readFrom(path('memory://groups.parquet')))))->batches($schema, 10, ReadPlan::window(100, new InMemoryIndexes()), new RustBackend())), "\n";
 ?>
 --EXPECT--
 row groups: 8192,8192,8192,8192,8192,8192,8192,8192
@@ -72,5 +77,4 @@ bool(true)
 bool(true)
 Flow\Parquet\Exception\InvalidArgumentException: arrow Parquet batch size must be greater than 0
 Flow\Parquet\Exception\InvalidArgumentException: arrow Parquet batch size must be greater than 0
-Flow\Parquet\Exception\InvalidArgumentException: arrow Parquet offset must be greater or equal to 0
-Flow\Parquet\Exception\InvalidArgumentException: arrow Parquet limit must be greater or equal to 0
+Flow\Parquet\Exception\InvalidArgumentException: A read plan over 100 rows cannot read a file of 65536 rows
diff --git a/src/extension/flow-php-ext/tests/phpt/071_parquet_no_leaks.phpt b/src/extension/flow-php-ext/tests/phpt/071_parquet_no_leaks.phpt
index fc8b479d01..b0d1dc7955 100644
--- a/src/extension/flow-php-ext/tests/phpt/071_parquet_no_leaks.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/071_parquet_no_leaks.phpt
@@ -48,7 +48,7 @@ $cycle = static function () use ($schema, $values, $extension, $options, $mismat
     }
 
     try {
-        rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $mismatched, 30, null, null);
+        rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $mismatched, 30);
         throw new LogicException('a mismatched schema was accepted');
     } catch (Flow\ETL\Exception\InvalidArgumentException) {
     }
diff --git a/src/extension/flow-php-ext/tests/phpt/072_parquet_allocations_counted.phpt b/src/extension/flow-php-ext/tests/phpt/072_parquet_allocations_counted.phpt
index 6847bfde4c..dd6fa2f828 100644
--- a/src/extension/flow-php-ext/tests/phpt/072_parquet_allocations_counted.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/072_parquet_allocations_counted.phpt
@@ -36,7 +36,7 @@ $writer->close();
 gc_collect_cycles();
 
 $before = (new RustBackend())->allocatedBytes();
-$reader = rust_parquet_batches($filesystem->readFrom(path('memory://held.parquet')), $schema, 1_000, null, null);
+$reader = rust_parquet_batches($filesystem->readFrom(path('memory://held.parquet')), $schema, 1_000);
 $held = [];
 
 foreach ($reader as $batch) {
diff --git a/src/extension/flow-php-ext/tests/phpt/089_parquet_arrow_c_no_leaks.phpt b/src/extension/flow-php-ext/tests/phpt/089_parquet_arrow_c_no_leaks.phpt
index 8bc9d2c594..333cf2bf03 100644
--- a/src/extension/flow-php-ext/tests/phpt/089_parquet_arrow_c_no_leaks.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/089_parquet_arrow_c_no_leaks.phpt
@@ -13,11 +13,13 @@ use Flow\ETL\Adapter\Parquet\{RustParquetOpenSink, SchemaConverter};
 use Flow\ETL\Column\RustBackend;
 use Flow\Parquet\Engine\Arrow\{OptionsConverter, SchemaConverter as ArrowSchemaConverter};
 use Flow\Parquet\Options;
+use Flow\Parquet\Reader\ReadPlan;
 use Flow\Parquet\ParquetFile\Compressions;
 
 use function Flow\ETL\DSL\{int_schema, list_schema, schema, str_schema};
 use function Flow\Filesystem\DSL\{memory_filesystem, path};
 use function Flow\Types\DSL\{type_integer, type_list, type_optional};
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
 
 $schema = schema(int_schema('id'), str_schema('name', nullable: true), list_schema('tags', type_list(type_optional(type_integer())), nullable: true));
 $extension = ArrowSchemaConverter::toExtension((new SchemaConverter())->toParquet($schema));
@@ -35,16 +37,17 @@ $cycle = static function () use ($schema, $extension, $options, $rows, $invalid,
     $writer->write($rows);
     $writer->close();
 
-    $reader = rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $schema, 30, null, null);
+    $reader = rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $schema, 30);
 
     foreach ($reader as $_) {
     }
 
-    $abandoned = rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $schema, 30, null, null);
+    $abandoned = rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $schema, 30);
     $abandoned->rewind();
     unset($abandoned);
 
-    $batches = new RustBatchReader(new RustParquetFileReader($filesystem->readFrom(path('memory://leaks.parquet'))), ['id', 'name', 'tags'], 30, null, null);
+    $file = new RustParquetFileReader($filesystem->readFrom(path('memory://leaks.parquet')));
+    $batches = new RustBatchReader($file, ['id', 'name', 'tags'], 30, ReadPlan::window($file->footer()->rowsNumber(), new InMemoryIndexes()));
     $batches->next();
     $twice = $batches->next();
     $copy = new RustParquetFileWriter($filesystem->writeTo(path('memory://copy.parquet')), $extension, Compressions::SNAPPY, $options, 30);
@@ -59,7 +62,7 @@ $cycle = static function () use ($schema, $extension, $options, $rows, $invalid,
     $copy->close();
 
     try {
-        rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $mismatched, 30, null, null);
+        rust_parquet_batches($filesystem->readFrom(path('memory://leaks.parquet')), $mismatched, 30);
         throw new LogicException('a string schema read an int column');
     } catch (Flow\ETL\Exception\InvalidArgumentException) {
     }
diff --git a/src/extension/flow-php-ext/tests/phpt/090_parquet_schema_refused_at_open.phpt b/src/extension/flow-php-ext/tests/phpt/090_parquet_schema_refused_at_open.phpt
index deffe049d4..543f224671 100644
--- a/src/extension/flow-php-ext/tests/phpt/090_parquet_schema_refused_at_open.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/090_parquet_schema_refused_at_open.phpt
@@ -38,8 +38,8 @@ for ($group = 0; $group < 8; $group++) {
 $groups->close();
 
 $mismatched = schema(str_schema('id'));
-echo outcome(static fn() => rust_parquet_batches($filesystem->readFrom(path('memory://empty.parquet')), $mismatched, 10, null, null)), "\n";
-echo outcome(static fn() => rust_parquet_batches($filesystem->readFrom(path('memory://groups.parquet')), $mismatched, 10, 1_000, null)), "\n";
+echo outcome(static fn() => rust_parquet_batches($filesystem->readFrom(path('memory://empty.parquet')), $mismatched, 10)), "\n";
+echo outcome(static fn() => rust_parquet_batches($filesystem->readFrom(path('memory://groups.parquet')), $mismatched, 10, 1_000)), "\n";
 echo outcome(static fn() => new Flow\ETL\Adapter\Parquet\RustParquetOpenSource(new stdClass())), "\n";
 echo outcome(static fn() => new Flow\ETL\Adapter\Parquet\RustParquetOpenSink(new stdClass())), "\n";
 ?>
diff --git a/src/extension/flow-php-ext/tests/phpt/091_parquet_canonical_layout_contract.phpt b/src/extension/flow-php-ext/tests/phpt/091_parquet_canonical_layout_contract.phpt
index c28642ea9d..ee7533def8 100644
--- a/src/extension/flow-php-ext/tests/phpt/091_parquet_canonical_layout_contract.phpt
+++ b/src/extension/flow-php-ext/tests/phpt/091_parquet_canonical_layout_contract.phpt
@@ -58,7 +58,7 @@ $writer->write(php_rows($schema, $values));
 $writer->close();
 
 $read = [];
-$reader = rust_parquet_batches($filesystem->readFrom(path('memory://layout.parquet')), $schema, 10, null, null);
+$reader = rust_parquet_batches($filesystem->readFrom(path('memory://layout.parquet')), $schema, 10);
 
 foreach ($reader as $batch) {
     array_push($read, ...$batch->toArray());
diff --git a/src/extension/flow-php-ext/tests/phpt/097_parquet_uint64_numeric_string.phpt b/src/extension/flow-php-ext/tests/phpt/097_parquet_uint64_numeric_string.phpt
new file mode 100644
index 0000000000..08f4d5c0ce
--- /dev/null
+++ b/src/extension/flow-php-ext/tests/phpt/097_parquet_uint64_numeric_string.phpt
@@ -0,0 +1,83 @@
+--TEST--
+A UINT_64 leaf crosses RustBatchReader → RustParquetOpenSource as a numeric_string column (arrow-ext hands it over as LargeBinary decimal text, the Bytes kind flow_php stores numeric_string in); DataFrame rows written through RustParquetOpenSink into an explicit UINT_64 schema take an integer column (negatives refused) and a numeric_string column (non-canonical text refused)
+--SKIPIF--
+<?php if (!extension_loaded("flow_php")) die("skip flow_php extension not loaded"); ?>
+<?php extension_loaded('arrow') || die('skip arrow'); ?>
+--FILE--
+<?php
+require __DIR__ . '/bootstrap.php';
+
+use Flow\ETL\Adapter\Parquet\{RustParquetOpenSink, SchemaConverter};
+use Flow\Parquet\Engine\RustParquetFileWriter;
+use Flow\Parquet\Engine\Arrow\{OptionsConverter, SchemaConverter as ArrowSchemaConverter};
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Writer;
+
+use function Flow\ETL\DSL\{definition_from_type, int_schema, schema};
+use function Flow\Filesystem\DSL\{memory_filesystem, path};
+use function Flow\Types\DSL\{type_equals, type_numeric_string, type_optional};
+
+$parquet = Schema::with(new FlatColumn('u', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)));
+$filesystem = memory_filesystem();
+$writer = new Writer(engine: new PhpParquetEngine());
+$writer->openForStream($filesystem->writeTo(path('memory://uint64.parquet')), $parquet);
+$writer->writeBatch([['u' => 0], ['u' => null], ['u' => '9223372036854775808'], ['u' => '18446744073709551615']]);
+$writer->close();
+
+$schema = (new SchemaConverter())->toFlow($parquet);
+var_dump(type_equals(type_numeric_string(), $schema->get('u')->type()));
+
+foreach (rust_parquet_batches($filesystem->readFrom(path('memory://uint64.parquet')), $schema, 10) as $batch) {
+    var_dump(type_equals(type_numeric_string(), $batch->column('u')->type()) || type_equals(type_optional(type_numeric_string()), $batch->column('u')->type()));
+    var_dump($batch->column('u')->values());
+}
+
+$write = static function (Flow\ETL\Schema $schema, array $values) use ($parquet, $filesystem): string {
+    return outcome(static function () use ($schema, $values, $parquet, $filesystem): array {
+        $sink = new RustParquetOpenSink(new RustParquetFileWriter(
+            $filesystem->writeTo(path('memory://uint64_write.parquet')),
+            ArrowSchemaConverter::toExtension($parquet),
+            Compressions::SNAPPY,
+            OptionsConverter::toExtension(Options::default()),
+            1_000,
+        ));
+
+        try {
+            $sink->write(php_rows($schema, $values));
+        } finally {
+            $sink->close();
+        }
+
+        return iterator_to_array(Reader::php()->readStream($filesystem->readFrom(path('memory://uint64_write.parquet')))->values());
+    });
+};
+
+echo $write(schema(int_schema('u', nullable: true)), [['u' => 0], ['u' => null], ['u' => PHP_INT_MAX]]), "\n";
+echo $write(schema(int_schema('u', nullable: true)), [['u' => 1], ['u' => -1]]), "\n";
+echo $write(schema(definition_from_type('u', type_numeric_string(), true)), [['u' => '18446744073709551615'], ['u' => null], ['u' => '0']]), "\n";
+echo $write(schema(definition_from_type('u', type_numeric_string(), true)), [['u' => '1'], ['u' => '007']]), "\n";
+?>
+--EXPECT--
+bool(true)
+bool(true)
+array(4) {
+  [0]=>
+  string(1) "0"
+  [1]=>
+  NULL
+  [2]=>
+  string(19) "9223372036854775808"
+  [3]=>
+  string(20) "18446744073709551615"
+}
+a:3:{i:0;a:1:{s:1:"u";s:1:"0";}i:1;a:1:{s:1:"u";N;}i:2;a:1:{s:1:"u";s:19:"9223372036854775807";}}
+Flow\Parquet\Exception\RuntimeException: Parquet column "u" row 1 holds a value out of the range arrow stores it in
+a:3:{i:0;a:1:{s:1:"u";s:20:"18446744073709551615";}i:1;a:1:{s:1:"u";N;}i:2;a:1:{s:1:"u";s:1:"0";}}
+Flow\Parquet\Exception\ValidationException: Column "u" row 1: expected int >= 0 or digit string, got string
diff --git a/src/extension/flow-php-ext/tests/phpt/bootstrap.php b/src/extension/flow-php-ext/tests/phpt/bootstrap.php
index 28a1cd3bdd..2e40002433 100644
--- a/src/extension/flow-php-ext/tests/phpt/bootstrap.php
+++ b/src/extension/flow-php-ext/tests/phpt/bootstrap.php
@@ -13,6 +13,7 @@
 use Flow\ETL\Tests\Fixtures\Enum\BasicEnum;
 use Flow\Filesystem\SourceStream;
 use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
 
 use function Flow\ETL\DSL\bool_schema;
 use function Flow\ETL\DSL\date_schema;
@@ -250,17 +251,29 @@ function comparable(mixed $value): string
 }
 
 /**
- * `RustParquetOpenSource::batches()` of `$schema`'s columns of the Parquet file in `$stream`, adopted by `RustBackend`.
+ * `RustParquetOpenSource::batches()` of `$schema`'s columns of the Parquet file in `$stream`, `$limit` rows from `$offset`,
+ * adopted by `RustBackend`.
  *
  * @param int<1, max> $batchSize
  */
-function rust_parquet_batches(SourceStream $stream, Schema $schema, int $batchSize, ?int $offset, ?int $limit): Iterator
-{
-    return (new RustParquetOpenSource(new RustParquetFileReader($stream)))->batches(
+function rust_parquet_batches(
+    SourceStream $stream,
+    Schema $schema,
+    int $batchSize,
+    int $offset = 0,
+    ?int $limit = null,
+): Iterator {
+    $file = new RustParquetFileReader($stream);
+
+    return (new RustParquetOpenSource($file))->batches(
         $schema,
         $batchSize,
-        $offset,
-        $limit,
+        ReadPlan::window(
+            $file->footer()->rowsNumber(),
+            new Flow\Parquet\Tests\Double\InMemoryIndexes(),
+            $offset,
+            $limit,
+        ),
         new RustBackend(),
     );
 }
diff --git a/src/lib/parquet-viewer/src/Flow/ParquetViewer/Command/ReadMetadataCommand.php b/src/lib/parquet-viewer/src/Flow/ParquetViewer/Command/ReadMetadataCommand.php
index 83b8eb2290..6f3df1d46a 100644
--- a/src/lib/parquet-viewer/src/Flow/ParquetViewer/Command/ReadMetadataCommand.php
+++ b/src/lib/parquet-viewer/src/Flow/ParquetViewer/Command/ReadMetadataCommand.php
@@ -4,11 +4,11 @@
 
 namespace Flow\ParquetViewer\Command;
 
-use Coduo\PHPHumanizer\StringHumanizer;
 use Flow\Parquet\Exception\InvalidArgumentException;
-use Flow\Parquet\ParquetFile\Schema\ColumnPrimitiveType;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\Reader;
+use Flow\ParquetViewer\StatisticFormatter;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Helper\TableCell;
@@ -23,8 +23,6 @@
 use function count;
 use function file_exists;
 use function Flow\Types\DSL\type_boolean;
-use function Flow\Types\DSL\type_optional;
-use function Flow\Types\DSL\type_scalar;
 use function Flow\Types\DSL\type_string;
 use function implode;
 use function number_format;
@@ -63,7 +61,8 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         $displayPageHeaders = type_boolean()->cast($input->getOption('page-headers'));
 
         try {
-            $parquetFile = (new Reader())->read($filePath);
+            $reader = new Reader();
+            $parquetFile = $reader->read($filePath);
             $metadata = $parquetFile->metadata();
         } catch (InvalidArgumentException $_e) {
             $style->error(sprintf('File "%s" is not a valid parquet file', $filePath));
@@ -191,6 +190,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
                 'distinct count',
             ]);
             $totalChunks = 0;
+            $formatter = new StatisticFormatter(DataConverter::initialize($reader->options));
 
             foreach ($metadata->rowGroups()->all() as $rowGroupIndex => $rowGroup) {
                 if ($totalChunks !== 0) {
@@ -206,25 +206,10 @@ protected function execute(InputInterface $input, OutputInterface $output): int
                     $column = $metadata->schema()->get($columnChunk->flatPath());
 
                     if ($statistics) {
-                        if (ColumnPrimitiveType::isString($column)) {
-                            $minVal = type_optional(type_scalar())->assert($statistics->min($column));
-                            $min = $minVal ? StringHumanizer::truncate((string) $minVal, 20, '...') : '-';
-                            $maxVal = type_optional(type_scalar())->assert($statistics->max($column));
-                            $max = $maxVal ? StringHumanizer::truncate((string) $maxVal, 20, '...') : '-';
-                            $minValueVal = type_optional(type_scalar())->assert($statistics->minValue($column));
-                            $minValue = $minValueVal
-                                ? StringHumanizer::truncate((string) $minValueVal, 20, '...')
-                                : '-';
-                            $maxValueVal = type_optional(type_scalar())->assert($statistics->maxValue($column));
-                            $maxValue = $maxValueVal
-                                ? StringHumanizer::truncate((string) $maxValueVal, 20, '...')
-                                : '-';
-                        } else {
-                            $min = type_scalar()->assert($statistics->min($column) ?? '-');
-                            $max = type_scalar()->assert($statistics->max($column) ?? '-');
-                            $minValue = type_scalar()->assert($statistics->minValue($column) ?? '-');
-                            $maxValue = type_scalar()->assert($statistics->maxValue($column) ?? '-');
-                        }
+                        $min = $formatter->format($column, $statistics->min($column));
+                        $max = $formatter->format($column, $statistics->max($column));
+                        $minValue = $formatter->format($column, $statistics->minValue($column));
+                        $maxValue = $formatter->format($column, $statistics->maxValue($column));
 
                         $nullCountVal = $statistics->nullCount();
                         $nullCount = $nullCountVal ? number_format($nullCountVal) : '-';
diff --git a/src/lib/parquet-viewer/src/Flow/ParquetViewer/StatisticFormatter.php b/src/lib/parquet-viewer/src/Flow/ParquetViewer/StatisticFormatter.php
new file mode 100644
index 0000000000..0625bbe433
--- /dev/null
+++ b/src/lib/parquet-viewer/src/Flow/ParquetViewer/StatisticFormatter.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ParquetViewer;
+
+use Coduo\PHPHumanizer\StringHumanizer;
+use DateInterval;
+use DateTimeInterface;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema\ColumnPrimitiveType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+
+use function Flow\Types\DSL\type_instance_of;
+use function Flow\Types\DSL\type_scalar;
+use function Flow\Types\DSL\type_union;
+
+final readonly class StatisticFormatter
+{
+    public function __construct(
+        private DataConverter $converter,
+    ) {}
+
+    public function format(FlatColumn $column, bool|float|int|string|null $physical): string
+    {
+        if ($physical === null) {
+            return '-';
+        }
+
+        $value = type_union(
+            type_scalar(),
+            type_instance_of(DateTimeInterface::class),
+            type_instance_of(DateInterval::class),
+        )->assert($this->converter->fromParquetType($column, $physical));
+
+        return match (true) {
+            $value instanceof DateTimeInterface => $value->format('Y-m-d H:i:s.u'),
+            $value instanceof DateInterval => $value->format('%H:%I:%S.%F'),
+            ColumnPrimitiveType::isString($column) && $column->logicalType()?->is(LogicalType::UUID) !== true
+                => StringHumanizer::truncate((string) $value, 20, '...'),
+            default => (string) $value,
+        };
+    }
+}
diff --git a/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Context/StyledOutput.php b/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Context/StyledOutput.php
new file mode 100644
index 0000000000..98448e2e85
--- /dev/null
+++ b/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Context/StyledOutput.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ParquetViewer\Tests\Context;
+
+use Closure;
+use Symfony\Component\Console\Input\ArrayInput;
+use Symfony\Component\Console\Output\BufferedOutput;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+final class StyledOutput
+{
+    /**
+     * @param Closure(SymfonyStyle): void $write
+     */
+    public static function captured(Closure $write): string
+    {
+        $output = new BufferedOutput();
+
+        $write(new SymfonyStyle(new ArrayInput([]), $output));
+
+        return $output->fetch();
+    }
+}
diff --git a/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Integration/ReadMetadataTest.php b/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Integration/ReadMetadataTest.php
index d131de8de6..ac0cab9fc1 100644
--- a/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Integration/ReadMetadataTest.php
+++ b/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Integration/ReadMetadataTest.php
@@ -4,14 +4,15 @@
 
 namespace Flow\ParquetViewer\Tests\Integration;
 
-use Closure;
 use Flow\ETL\Tests\CommandOutputNormalizer;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\TestParquetFile;
+use Flow\Parquet\Writer;
 use Flow\ParquetViewer\Parquet;
+use Flow\ParquetViewer\Tests\Context\StyledOutput;
 use PHPUnit\Framework\TestCase;
-use Symfony\Component\Console\Input\ArrayInput;
-use Symfony\Component\Console\Output\BufferedOutput;
 use Symfony\Component\Console\Style\OutputStyle;
-use Symfony\Component\Console\Style\SymfonyStyle;
 use Symfony\Component\Console\Tester\ApplicationTester;
 
 use function realpath;
@@ -20,6 +21,11 @@ final class ReadMetadataTest extends TestCase
 {
     use CommandOutputNormalizer;
 
+    protected function tearDown(): void
+    {
+        TestParquetFile::remove($this);
+    }
+
     public function test_reading_metadata_from_non_json_file(): void
     {
         $application = new Parquet();
@@ -34,7 +40,7 @@ public function test_reading_metadata_from_non_json_file(): void
             'file' => $path,
         ]);
 
-        $expected = $this->captureConsoleOutput(static fn(OutputStyle $io) => $io->error(
+        $expected = StyledOutput::captured(static fn(OutputStyle $io) => $io->error(
             "File \"{$path}\" is not a valid parquet file",
         ));
 
@@ -68,14 +74,41 @@ public function test_reading_metadata_from_parquet_file(): void
         static::assertSame(0, $tester->getStatusCode());
     }
 
-    private function captureConsoleOutput(Closure $closure): string
+    public function test_decimal_statistics_are_shown_as_decimals(): void
     {
-        $output = new BufferedOutput();
+        $path = TestParquetFile::path($this);
+        (new Writer())->write($path, Schema::with(FlatColumn::decimal('amount', 10, 2)), [
+            ['amount' => -3.5],
+            ['amount' => 1.25],
+        ]);
+        $application = new Parquet();
+        $application->setAutoExit(false);
+        $application->setCatchExceptions(false);
+        $tester = new ApplicationTester($application);
 
-        $io = new SymfonyStyle(new ArrayInput([]), $output);
+        $tester->run(['command' => 'read:metadata', 'file' => $path, '--statistics' => 1]);
 
-        $closure($io);
+        self::assertCommandOutputContains('-3.5', $tester->getDisplay());
+        self::assertCommandOutputContains('1.25', $tester->getDisplay());
+        static::assertSame(0, $tester->getStatusCode());
+    }
 
-        return $output->fetch();
+    public function test_uuid_statistics_are_shown_as_uuids(): void
+    {
+        $path = TestParquetFile::path($this);
+        (new Writer())->write($path, Schema::with(FlatColumn::uuid('id')), [
+            ['id' => '0f8fad5b-d9cb-469f-a165-70867728950e'],
+            ['id' => '7c9e6679-7425-40de-944b-e07fc1f90ae7'],
+        ]);
+        $application = new Parquet();
+        $application->setAutoExit(false);
+        $application->setCatchExceptions(false);
+        $tester = new ApplicationTester($application);
+
+        $tester->run(['command' => 'read:metadata', 'file' => $path, '--statistics' => 1]);
+
+        self::assertCommandOutputContains('0f8fad5b-d9cb-469f-a165-70867728950e', $tester->getDisplay());
+        self::assertCommandOutputContains('7c9e6679-7425-40de-944b-e07fc1f90ae7', $tester->getDisplay());
+        static::assertSame(0, $tester->getStatusCode());
     }
 }
diff --git a/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Unit/StatisticFormatterTest.php b/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Unit/StatisticFormatterTest.php
new file mode 100644
index 0000000000..ad0e416326
--- /dev/null
+++ b/src/lib/parquet-viewer/tests/Flow/ParquetViewer/Tests/Unit/StatisticFormatterTest.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ParquetViewer\Tests\Unit;
+
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\ParquetViewer\StatisticFormatter;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+use function hex2bin;
+
+final class StatisticFormatterTest extends TestCase
+{
+    /**
+     * @return Generator<string, array{FlatColumn, bool|float|int|string|null, string}>
+     */
+    public static function statistics(): Generator
+    {
+        yield 'absent' => [FlatColumn::int64('i'), null, '-'];
+        yield 'int' => [FlatColumn::int64('i'), 7, '7'];
+        yield 'boolean' => [FlatColumn::boolean('b'), true, '1'];
+        yield 'decimal' => [FlatColumn::decimal('d', 10, 2), -350, '-3.5'];
+        yield 'datetime' => [FlatColumn::dateTime('t'), 1_500_000, '1970-01-01 00:00:01.500000'];
+        yield 'time' => [FlatColumn::time('t'), 3_723_500_000, '01:02:03.500000'];
+        yield 'uuid stays whole' => [
+            FlatColumn::uuid('u'),
+            (string) hex2bin('0f8fad5bd9cb469fa16570867728950e'),
+            '0f8fad5b-d9cb-469f-a165-70867728950e',
+        ];
+        yield 'short string whole' => [FlatColumn::string('s'), 'the quick brown fox', 'the quick brown fox'];
+        yield 'long string truncated at a word' => [
+            FlatColumn::string('s'),
+            'the quick brown fox jumps over',
+            'the quick brown fox jumps...',
+        ];
+    }
+
+    #[DataProvider('statistics')]
+    public function test_format(FlatColumn $column, bool|float|int|string|null $physical, string $expected): void
+    {
+        static::assertSame($expected, (new StatisticFormatter(DataConverter::initialize(Options::default())))->format(
+            $column,
+            $physical,
+        ));
+    }
+}
diff --git a/src/lib/parquet/composer.json b/src/lib/parquet/composer.json
index d81ab334c3..2b3c118c75 100644
--- a/src/lib/parquet/composer.json
+++ b/src/lib/parquet/composer.json
@@ -40,6 +40,7 @@
         "files": [
             "src/Flow/Parquet/functions.php",
             "src/Flow/Parquet/Binary/functions.php",
+            "src/Flow/Parquet/DSL/functions.php",
             "src/stubs.php"
         ]
     },
diff --git a/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomFilterOptions.php b/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomFilterOptions.php
new file mode 100644
index 0000000000..0b499798f9
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomFilterOptions.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\BloomFilter;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+
+use function get_debug_type;
+
+final readonly class BloomFilterOptions
+{
+    /**
+     * arrow-rs DEFAULT_MAX_ROW_GROUP_ROW_COUNT, its default ndv.
+     */
+    public const int DEFAULT_NDV = 1_048_576;
+
+    /**
+     * @param null|int $ndv the distinct values a row group is expected to hold, null for DEFAULT_NDV
+     */
+    public function __construct(
+        public float $fpp = 0.05,
+        public ?int $ndv = null,
+    ) {
+        if (!($fpp > 0.0 && $fpp < 1.0)) {
+            throw new InvalidArgumentException('A bloom filter false positive probability must be between 0 and 1, got '
+            . $fpp);
+        }
+
+        if ($ndv !== null && $ndv < 1) {
+            throw new InvalidArgumentException('A bloom filter ndv must be at least 1, got ' . $ndv);
+        }
+    }
+
+    /**
+     * Option::COLUMNS_BLOOM_FILTERS, refused when a value is not a BloomFilterOptions.
+     *
+     * @return array<string, self>
+     */
+    public static function forColumns(Options $options): array
+    {
+        $columns = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($options->getArray(Option::COLUMNS_BLOOM_FILTERS) ?? [] as $path => $bloomFilter) {
+            if (!$bloomFilter instanceof self) {
+                throw new InvalidArgumentException(
+                    'Option COLUMNS_BLOOM_FILTERS takes BloomFilterOptions, got '
+                    . get_debug_type($bloomFilter)
+                    . ' for column "'
+                    . $path
+                    . '"',
+                );
+            }
+
+            $columns[(string) $path] = $bloomFilter;
+        }
+
+        return $columns;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomFilterReader.php b/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomFilterReader.php
new file mode 100644
index 0000000000..c7cd2b1455
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomFilterReader.php
@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\BloomFilter;
+
+use Flow\Filesystem\SourceStream;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
+use Flow\Parquet\ThriftModel\BloomFilterHeader;
+
+use function strlen;
+use function substr;
+
+final readonly class BloomFilterReader
+{
+    /**
+     * arrow-rs SBBF_HEADER_SIZE_ESTIMATE: read when the chunk does not record the filter's length.
+     */
+    private const int HEADER_SIZE_ESTIMATE = 20;
+
+    public function __construct(
+        private SourceStream $stream,
+    ) {}
+
+    /**
+     * Null when the chunk has no bloom filter, records an offset no filter can be read from, or holds one that is not a
+     * split block, xxh64, uncompressed filter.
+     */
+    public function read(ColumnChunk $chunk): ?Sbbf
+    {
+        $offset = $chunk->bloomFilterOffset();
+
+        if ($offset === null || $offset < 0) {
+            return null;
+        }
+
+        $length = $chunk->bloomFilterLength();
+
+        if ($length !== null && $length < 1) {
+            $length = null;
+        }
+
+        $bytes = $this->stream->read($length ?? self::HEADER_SIZE_ESTIMATE, $offset);
+        $buffer = new MemoryBuffer($bytes);
+        $header = new BloomFilterHeader();
+        $header->read(new CompactProtocol($buffer));
+
+        if (!self::supported($header)) {
+            return null;
+        }
+
+        $numBytes = (int) $header->numBytes;
+
+        if ($numBytes < 1) {
+            throw new RuntimeException('The bloom filter at offset ' . $offset . ' declares ' . $numBytes . ' bytes');
+        }
+
+        $headerSize = strlen($bytes) - $buffer->available();
+        $bitset = $length === null
+            ? $this->stream->read($numBytes, $offset + $headerSize)
+            : substr($bytes, $headerSize, $numBytes);
+
+        if (strlen($bitset) !== $numBytes) {
+            throw new RuntimeException(
+                'The bloom filter at offset '
+                . $offset
+                . ' declares '
+                . $numBytes
+                . ' bytes, '
+                . strlen($bitset)
+                . ' were read',
+            );
+        }
+
+        return Sbbf::fromBytes($bitset);
+    }
+
+    private static function supported(BloomFilterHeader $header): bool
+    {
+        return (
+            $header->algorithm->BLOCK !== null
+            && $header->hash->XXHASH !== null
+            && $header->compression->UNCOMPRESSED !== null
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomHash.php b/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomHash.php
new file mode 100644
index 0000000000..003e8aacf0
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/BloomFilter/BloomHash.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\BloomFilter;
+
+use Flow\Parquet\Binary\ByteOrder;
+use Flow\Parquet\Data\PhysicalCodec;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function Flow\Parquet\Binary\decode_i64;
+use function hash;
+
+final readonly class BloomHash
+{
+    public function __construct(
+        private PhysicalCodec $codec = new PhysicalCodec(),
+    ) {}
+
+    /**
+     * xxh64 (seed 0) of the PLAIN encoding, without BYTE_ARRAY's length prefix; the u64 as a signed PHP int.
+     */
+    public function of(FlatColumn $column, mixed $physical): int
+    {
+        return decode_i64(ByteOrder::BIG_ENDIAN, hash(
+            'xxh64',
+            $this->codec->encodeStatistic($column, $physical),
+            true,
+        ))[0];
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/BloomFilter/Sbbf.php b/src/lib/parquet/src/Flow/Parquet/BloomFilter/Sbbf.php
new file mode 100644
index 0000000000..18ef211ab4
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/BloomFilter/Sbbf.php
@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\BloomFilter;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
+use Flow\Parquet\ThriftModel\BloomFilterAlgorithm;
+use Flow\Parquet\ThriftModel\BloomFilterCompression;
+use Flow\Parquet\ThriftModel\BloomFilterHash;
+use Flow\Parquet\ThriftModel\BloomFilterHeader;
+use Flow\Parquet\ThriftModel\SplitBlockAlgorithm;
+use Flow\Parquet\ThriftModel\Uncompressed;
+use Flow\Parquet\ThriftModel\XxHash;
+
+use function intdiv;
+use function ord;
+use function strlen;
+
+/**
+ * A split block bloom filter: blocks of eight little-endian u32 words, one bit set per word for each value.
+ */
+final readonly class Sbbf
+{
+    public const int BLOCK_BYTES = 32;
+
+    private const array SALT = [
+        0x47B6137B,
+        0x44974D91,
+        0x8824AD5B,
+        0xA2B7289D,
+        0x705495C7,
+        0x2DF1424B,
+        0x9EFC4947,
+        0x5C6BFB31,
+    ];
+
+    private int $blocks;
+
+    private function __construct(
+        private string $bitset,
+    ) {
+        $this->blocks = intdiv(strlen($bitset), self::BLOCK_BYTES);
+    }
+
+    public static function fromBytes(string $bitset): self
+    {
+        $length = strlen($bitset);
+
+        if ($length < self::BLOCK_BYTES || ($length % self::BLOCK_BYTES) !== 0) {
+            throw new InvalidArgumentException(
+                'A bloom filter bitset holds whole blocks of '
+                . self::BLOCK_BYTES
+                . ' bytes, got '
+                . $length
+                . ' bytes',
+            );
+        }
+
+        return new self($bitset);
+    }
+
+    /**
+     * The eight bits a hash sets in a bitset of $blocks blocks, numbered from the first byte's lowest bit. $hash is the
+     * xxh64 u64 as a signed PHP int, so every shift is masked and the 32-bit multiply is split in 16-bit halves.
+     *
+     * @return list<int>
+     */
+    public static function bits(int $hash, int $blocks): array
+    {
+        $block = ((($hash >> 32) & 0xFFFFFFFF) * $blocks) >> 32;
+        $x = $hash & 0xFFFFFFFF;
+        $bits = [];
+
+        foreach (self::SALT as $word => $salt) {
+            $product = ((((($x >> 16) * $salt) & 0xFFFF) << 16) + (($x & 0xFFFF) * $salt)) & 0xFFFFFFFF;
+            $bits[] = ($block * self::BLOCK_BYTES * 8) + ($word * 32) + ($product >> 27);
+        }
+
+        return $bits;
+    }
+
+    /**
+     * As a file holds it, the form BloomFilterReader reads: the thrift header, then the bitset.
+     */
+    public function serialized(): string
+    {
+        (new BloomFilterHeader([
+            'numBytes' => strlen($this->bitset),
+            'algorithm' => new BloomFilterAlgorithm(['BLOCK' => new SplitBlockAlgorithm()]),
+            'hash' => new BloomFilterHash(['XXHASH' => new XxHash()]),
+            'compression' => new BloomFilterCompression(['UNCOMPRESSED' => new Uncompressed()]),
+        ]))->write(new CompactProtocol($header = new MemoryBuffer()));
+
+        return $header->data() . $this->bitset;
+    }
+
+    /**
+     * False only when the value was never inserted.
+     */
+    public function check(int $hash): bool
+    {
+        foreach (self::bits($hash, $this->blocks) as $bit) {
+            if ((ord($this->bitset[$bit >> 3]) & (1 << ($bit & 7))) === 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/BloomFilter/SbbfBuilder.php b/src/lib/parquet/src/Flow/Parquet/BloomFilter/SbbfBuilder.php
new file mode 100644
index 0000000000..c10743470c
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/BloomFilter/SbbfBuilder.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\BloomFilter;
+
+use function chr;
+use function count_chars;
+use function decbin;
+use function intdiv;
+use function log;
+use function min;
+use function ord;
+use function str_repeat;
+use function strlen;
+use function substr;
+use function substr_count;
+
+/**
+ * Sized and folded like arrow-rs 60: optimal_num_of_bytes, then fold_to_target_fpp.
+ */
+final class SbbfBuilder
+{
+    private const int MAX_BYTES = 128 * 1024 * 1024;
+
+    private readonly int $blocks;
+
+    private function __construct(
+        private string $bitset,
+        private readonly float $fpp,
+    ) {
+        $this->blocks = intdiv(strlen($bitset), Sbbf::BLOCK_BYTES);
+    }
+
+    public static function for(BloomFilterOptions $options): self
+    {
+        $bits = min(
+            (-8.0 * ($options->ndv ?? BloomFilterOptions::DEFAULT_NDV)) / log(1.0 - $options->fpp ** (1.0 / 8.0)),
+            self::MAX_BYTES * 8.0,
+        );
+        $bytes = Sbbf::BLOCK_BYTES;
+
+        while ($bytes < intdiv((int) $bits, 8)) {
+            $bytes <<= 1;
+        }
+
+        return new self(str_repeat("\0", $bytes), $options->fpp);
+    }
+
+    public function build(): Sbbf
+    {
+        $folds = $this->folds();
+
+        if ($folds === 0) {
+            return Sbbf::fromBytes($this->bitset);
+        }
+
+        $groupBytes = Sbbf::BLOCK_BYTES << $folds;
+        $folded = '';
+
+        for ($start = 0; $start < strlen($this->bitset); $start += $groupBytes) {
+            $block = substr($this->bitset, $start, Sbbf::BLOCK_BYTES);
+
+            for ($next = Sbbf::BLOCK_BYTES; $next < $groupBytes; $next += Sbbf::BLOCK_BYTES) {
+                $block |= substr($this->bitset, $start + $next, Sbbf::BLOCK_BYTES);
+            }
+
+            $folded .= $block;
+        }
+
+        return Sbbf::fromBytes($folded);
+    }
+
+    public function insert(int $hash): void
+    {
+        foreach (Sbbf::bits($hash, $this->blocks) as $bit) {
+            $byte = $bit >> 3;
+            $this->bitset[$byte] = chr(ord($this->bitset[$byte]) | (1 << ($bit & 7)));
+        }
+    }
+
+    /**
+     * arrow-rs num_folds_for_target_fpp: the most halvings whose estimated false positive probability, with every
+     * block filled at the average rate f, stays within fpp: (1 - (1 - f)^(2^k))^8.
+     */
+    private function folds(): int
+    {
+        $maxFolds = strlen(decbin($this->blocks)) - 1;
+        $setBits = 0;
+
+        foreach (count_chars($this->bitset, 1) as $byte => $count) {
+            $setBits += $count * substr_count(decbin($byte), '1');
+        }
+
+        if ($setBits === 0) {
+            return $maxFolds;
+        }
+
+        $empty = 1.0 - ($setBits / ($this->blocks * 256.0));
+        $folds = 0;
+
+        while ($folds < $maxFolds) {
+            $empty *= $empty;
+            $filled = 1.0 - $empty;
+            $filled *= $filled;
+            $filled *= $filled;
+
+            if (($filled * $filled) > $this->fpp) {
+                break;
+            }
+
+            $folds++;
+        }
+
+        return $folds;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/DSL/functions.php b/src/lib/parquet/src/Flow/Parquet/DSL/functions.php
new file mode 100644
index 0000000000..5199fb40c2
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/DSL/functions.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\DSL;
+
+use Flow\Documentation\Attribute\DocumentationDSL;
+use Flow\Documentation\Attribute\Module;
+use Flow\Documentation\Attribute\Type;
+use Flow\Parquet\Filter\ColumnRef;
+use Flow\Parquet\Query;
+
+#[DocumentationDSL(module: Module::PARQUET, type: Type::HELPER)]
+function parquet_column(string $path): ColumnRef
+{
+    return new ColumnRef($path);
+}
+
+#[DocumentationDSL(module: Module::PARQUET, type: Type::HELPER)]
+function parquet_query(): Query
+{
+    return new Query();
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Data/PhysicalCodec.php b/src/lib/parquet/src/Flow/Parquet/Data/PhysicalCodec.php
new file mode 100644
index 0000000000..b1dd32b1f3
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Data/PhysicalCodec.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Data;
+
+use Flow\Parquet\Binary\ByteOrder;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+use function chr;
+use function Flow\Parquet\Binary\decode_f32;
+use function Flow\Parquet\Binary\decode_f64;
+use function Flow\Parquet\Binary\decode_i32;
+use function Flow\Parquet\Binary\decode_i64;
+use function Flow\Parquet\Binary\encode_f32;
+use function Flow\Parquet\Binary\encode_f64;
+use function Flow\Parquet\Binary\encode_i32;
+use function Flow\Parquet\Binary\encode_i64;
+use function get_debug_type;
+use function is_bool;
+use function is_float;
+use function is_int;
+use function is_string;
+use function ord;
+use function sprintf;
+use function strlen;
+
+final readonly class PhysicalCodec
+{
+    /**
+     * Null for bytes whose width does not fit the physical type: older flow writers doubled INT64 bounds.
+     */
+    public function decodeStatistic(FlatColumn $column, string $bytes): bool|float|int|string|null
+    {
+        $width = $this->statisticWidth($column);
+
+        if ($width !== null && strlen($bytes) !== $width) {
+            return null;
+        }
+
+        return match ($column->type()) {
+            PhysicalType::BOOLEAN => ord($bytes) !== 0,
+            PhysicalType::INT32 => decode_i32(ByteOrder::LITTLE_ENDIAN, $bytes)[0],
+            PhysicalType::INT64 => decode_i64(ByteOrder::LITTLE_ENDIAN, $bytes)[0],
+            PhysicalType::FLOAT => decode_f32(ByteOrder::LITTLE_ENDIAN, $bytes)[0],
+            PhysicalType::DOUBLE => decode_f64(ByteOrder::LITTLE_ENDIAN, $bytes)[0],
+            PhysicalType::INT96, PhysicalType::FIXED_LEN_BYTE_ARRAY, PhysicalType::BYTE_ARRAY => $bytes,
+        };
+    }
+
+    public function encodeStatistic(FlatColumn $column, mixed $physical): string
+    {
+        $encoded = match ($column->type()) {
+            PhysicalType::BOOLEAN => is_bool($physical) ? chr((int) $physical) : null,
+            PhysicalType::INT32 => is_int($physical) ? encode_i32(ByteOrder::LITTLE_ENDIAN, [$physical]) : null,
+            PhysicalType::INT64 => is_int($physical) ? encode_i64(ByteOrder::LITTLE_ENDIAN, [$physical]) : null,
+            PhysicalType::FLOAT => is_float($physical) || is_int($physical)
+                ? encode_f32(ByteOrder::LITTLE_ENDIAN, [(float) $physical])
+                : null,
+            PhysicalType::DOUBLE => is_float($physical) || is_int($physical)
+                ? encode_f64(ByteOrder::LITTLE_ENDIAN, [(float) $physical])
+                : null,
+            PhysicalType::INT96, PhysicalType::FIXED_LEN_BYTE_ARRAY, PhysicalType::BYTE_ARRAY => is_string($physical)
+                ? $physical
+                : null,
+        };
+
+        return $encoded ?? throw new InvalidArgumentException(sprintf(
+            'Column "%s": %s is not a %s physical value',
+            $column->flatPath(),
+            get_debug_type($physical),
+            $column->type()->name,
+        ));
+    }
+
+    /**
+     * Null where the width varies (BYTE_ARRAY) or a bound may be truncated (FIXED_LEN_BYTE_ARRAY).
+     */
+    private function statisticWidth(FlatColumn $column): ?int
+    {
+        return match ($column->type()) {
+            PhysicalType::BOOLEAN => 1,
+            PhysicalType::INT32, PhysicalType::FLOAT => 4,
+            PhysicalType::INT64, PhysicalType::DOUBLE => 8,
+            PhysicalType::INT96 => 12,
+            PhysicalType::FIXED_LEN_BYTE_ARRAY, PhysicalType::BYTE_ARRAY => null,
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Data/PhysicalOrder.php b/src/lib/parquet/src/Flow/Parquet/Data/PhysicalOrder.php
new file mode 100644
index 0000000000..2b55d22086
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Data/PhysicalOrder.php
@@ -0,0 +1,193 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Data;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Integer;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+use function chr;
+use function is_float;
+use function is_int;
+use function is_nan;
+use function is_string;
+use function ord;
+use function pack;
+use function str_pad;
+use function strcmp;
+use function strlen;
+use function substr;
+use function unpack;
+
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+use const STR_PAD_LEFT;
+
+enum PhysicalOrder
+{
+    case Boolean;
+    case Bytes;
+    case Decimal;
+    case Double;
+    case Float;
+    case Float16;
+    case Signed;
+    case Unordered;
+    case Unsigned32;
+    case Unsigned64;
+
+    /**
+     * Two's complement decimals are sign-extended to this many bytes: a DECIMAL(76) needs 32.
+     */
+    private const int DECIMAL_KEY_WIDTH = 32;
+
+    public static function forColumn(FlatColumn $column): self
+    {
+        $logical = $column->logicalType();
+
+        return match ($column->type()) {
+            PhysicalType::BOOLEAN => self::Boolean,
+            PhysicalType::INT32 => Integer::forColumn($column)?->isSigned() === false ? self::Unsigned32 : self::Signed,
+            PhysicalType::INT64 => Integer::forColumn($column)?->isSigned() === false ? self::Unsigned64 : self::Signed,
+            PhysicalType::FLOAT => self::Float,
+            PhysicalType::DOUBLE => self::Double,
+            PhysicalType::BYTE_ARRAY, PhysicalType::FIXED_LEN_BYTE_ARRAY => match (true) {
+                $column->convertedType() === ConvertedType::INTERVAL => self::Unordered,
+                $logical?->is(LogicalType::DECIMAL) === true,
+                $column->convertedType() === ConvertedType::DECIMAL,
+                    => self::Decimal,
+                $logical?->is(LogicalType::FLOAT16) === true => self::Float16,
+                default => self::Bytes,
+            },
+            PhysicalType::INT96 => self::Unordered,
+        };
+    }
+
+    /**
+     * Orders two physical values as parquet statistics do: bytes unsigned, DECIMAL signed two's complement, UINT
+     * unsigned, floats by IEEE 754 total order (-0.0 < +0.0, NaN greatest), false < true.
+     */
+    public function compare(bool|float|int|string $a, bool|float|int|string $b): int
+    {
+        return $this->compareKeys($this->key($a), $this->key($b));
+    }
+
+    public function compareKeys(int|string $a, int|string $b): int
+    {
+        return is_int($a) ? $a <=> $b : strcmp($a, (string) $b) <=> 0;
+    }
+
+    public function isFloatingPoint(): bool
+    {
+        return $this === self::Float || $this === self::Double || $this === self::Float16;
+    }
+
+    /**
+     * Whether the deprecated statistics min/max may hold the column's bounds (arrow-rs SortOrder::SIGNED).
+     */
+    public function isSigned(): bool
+    {
+        return $this === self::Signed || $this === self::Decimal;
+    }
+
+    public function isNan(bool|float|int|string $value): bool
+    {
+        return match ($this) {
+            self::Double, self::Float => is_float($value) && is_nan($value),
+            self::Float16 => is_string($value)
+                && strlen($value) === 2
+                && ($this->float16Bits($value) & 0x7FFF) > 0x7C00,
+            default => false,
+        };
+    }
+
+    public function isUnordered(): bool
+    {
+        return $this === self::Unordered;
+    }
+
+    public function isZero(bool|float|int|string $value): bool
+    {
+        return match ($this) {
+            self::Double, self::Float => is_float($value) && $value === 0.0,
+            self::Float16 => is_string($value) && strlen($value) === 2 && ($this->float16Bits($value) & 0x7FFF) === 0,
+            default => false,
+        };
+    }
+
+    public function key(bool|float|int|string $value): int|string
+    {
+        return match ($this) {
+            self::Boolean, self::Signed => (int) $value,
+            self::Unsigned32 => (int) $value & 0xFFFFFFFF,
+            self::Unsigned64 => (int) $value ^ PHP_INT_MIN,
+            self::Float => $this->float32Key((float) $value),
+            self::Double => $this->float64Key((float) $value),
+            self::Float16 => $this->float16Key((string) $value),
+            self::Bytes => (string) $value,
+            self::Decimal => $this->decimalKey((string) $value),
+            self::Unordered => throw new InvalidArgumentException('INT96 and INTERVAL have no physical order'),
+        };
+    }
+
+    public function zero(bool $negative): float|string
+    {
+        return match ($this) {
+            self::Double, self::Float => $negative ? -0.0 : 0.0,
+            self::Float16 => $negative ? "\x00\x80" : "\x00\x00",
+            default => throw new InvalidArgumentException($this->name . ' has no signed zero'),
+        };
+    }
+
+    private function decimalKey(string $bytes): string
+    {
+        if ($bytes === '') {
+            return '';
+        }
+
+        $extension = ord($bytes[0]) >= 0x80 ? "\xFF" : "\x00";
+
+        while (strlen($bytes) > self::DECIMAL_KEY_WIDTH && $bytes[0] === $extension && $bytes[1] === $extension) {
+            $bytes = substr($bytes, 1);
+        }
+
+        $padded = str_pad($bytes, self::DECIMAL_KEY_WIDTH, $extension, STR_PAD_LEFT);
+
+        return chr(ord($padded[0]) ^ 0x80) . substr($padded, 1);
+    }
+
+    private function float16Bits(string $bytes): int
+    {
+        return (ord($bytes[1]) << 8) | ord($bytes[0]);
+    }
+
+    private function float16Key(string $bytes): int
+    {
+        $unsigned = $this->float16Bits($bytes);
+        $bits = $unsigned >= 0x8000 ? $unsigned - 0x10000 : $unsigned;
+
+        return $bits ^ (($bits >> 15) & 0x7FFF);
+    }
+
+    private function float32Key(float $value): int
+    {
+        /** @var array{1: int} $unpacked */
+        $unpacked = unpack('V', pack('g', $value));
+        $bits = $unpacked[1] >= 0x80000000 ? $unpacked[1] - 0x100000000 : $unpacked[1];
+
+        return $bits ^ (($bits >> 31) & 0x7FFFFFFF);
+    }
+
+    private function float64Key(float $value): int
+    {
+        /** @var array{1: int} $unpacked */
+        $unpacked = unpack('P', pack('e', $value));
+
+        return $unpacked[1] ^ (($unpacked[1] >> 63) & PHP_INT_MAX);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Data/PlainValueUnpacker.php b/src/lib/parquet/src/Flow/Parquet/Data/PlainValueUnpacker.php
index abf0bef1a5..29014fa728 100644
--- a/src/lib/parquet/src/Flow/Parquet/Data/PlainValueUnpacker.php
+++ b/src/lib/parquet/src/Flow/Parquet/Data/PlainValueUnpacker.php
@@ -7,22 +7,15 @@
 use Flow\Parquet\Binary\ByteOrder;
 use Flow\Parquet\BinaryReader;
 use Flow\Parquet\Exception\RuntimeException;
-use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
-use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Generator;
 
-use function bin2hex;
-use function Flow\Parquet\Binary\decode_decimal;
 use function Flow\Parquet\Binary\decode_f32;
 use function Flow\Parquet\Binary\decode_f64;
-use function Flow\Parquet\Binary\decode_i16;
 use function Flow\Parquet\Binary\decode_i32;
 use function Flow\Parquet\Binary\decode_i64;
 use function Flow\Parquet\Binary\decode_u32;
-use function sprintf;
-use function substr;
 
 final readonly class PlainValueUnpacker
 {
@@ -42,30 +35,16 @@ public function unpack(FlatColumn $column, int $total): Generator
 
         yield from match ($column->type()) {
             PhysicalType::BOOLEAN => $this->unpackBooleans($total),
-            PhysicalType::INT32 => $this->unpackInt32($column, $total),
+            PhysicalType::INT32 => $this->unpackInt32($total),
             PhysicalType::INT64 => $this->unpackInt64($total),
             PhysicalType::INT96 => $this->unpackInt96($total),
             PhysicalType::FLOAT => $this->unpackFloats($total),
             PhysicalType::DOUBLE => $this->unpackDoubles($total),
-            PhysicalType::BYTE_ARRAY => $this->unpackByteArray($column, $total),
+            PhysicalType::BYTE_ARRAY => $this->unpackByteArray($total),
             PhysicalType::FIXED_LEN_BYTE_ARRAY => $this->unpackFixedLenByteArray($column, $total),
         };
     }
 
-    private function rawBytesToUuidString(string $raw): string
-    {
-        $hex = bin2hex($raw);
-
-        return sprintf(
-            '%s-%s-%s-%s-%s',
-            substr($hex, 0, 8),
-            substr($hex, 8, 4),
-            substr($hex, 12, 4),
-            substr($hex, 16, 4),
-            substr($hex, 20, 12),
-        );
-    }
-
     /**
      * @return \Generator<bool>
      */
@@ -77,16 +56,12 @@ private function unpackBooleans(int $total): Generator
     }
 
     /**
-     * @return \Generator<float|string>
+     * @return \Generator<string>
      */
-    private function unpackByteArray(FlatColumn $column, int $total): Generator
+    private function unpackByteArray(int $total): Generator
     {
-        $decimal = $column->logicalType()?->decimalData();
-
         for ($i = 0; $i < $total; $i++) {
-            $bytes = $this->reader->readBytes(decode_u32($this->byteOrder, $this->reader->readBytes(4))[0]);
-
-            yield $decimal === null ? $bytes : decode_decimal($bytes, $decimal->scale());
+            yield $this->reader->readBytes(decode_u32($this->byteOrder, $this->reader->readBytes(4))[0]);
         }
     }
 
@@ -99,7 +74,7 @@ private function unpackDoubles(int $total): Generator
     }
 
     /**
-     * @return \Generator<float|string>
+     * @return \Generator<string>
      */
     private function unpackFixedLenByteArray(FlatColumn $column, int $total): Generator
     {
@@ -109,17 +84,8 @@ private function unpackFixedLenByteArray(FlatColumn $column, int $total): Genera
             throw new RuntimeException('FIXED_LEN_BYTE_ARRAY requires typeLength in schema');
         }
 
-        $logicalType = $column->logicalType();
-        $decimalData = $logicalType?->decimalData();
-
         for ($i = 0; $i < $total; $i++) {
-            $raw = $this->reader->readBytes($typeLength);
-
-            yield match ($logicalType?->name()) {
-                LogicalType::DECIMAL => decode_decimal($raw, $decimalData?->scale() ?? 0),
-                LogicalType::UUID => $this->rawBytesToUuidString($raw),
-                default => $raw,
-            };
+            yield $this->reader->readBytes($typeLength);
         }
     }
 
@@ -134,14 +100,8 @@ private function unpackFloats(int $total): Generator
     /**
      * @return \Generator<int>
      */
-    private function unpackInt32(FlatColumn $column, int $total): Generator
+    private function unpackInt32(int $total): Generator
     {
-        if ($column->convertedType() === ConvertedType::INT_16) {
-            yield from decode_i16($this->byteOrder, $this->reader->readBytes($total * 2));
-
-            return;
-        }
-
         yield from decode_i32($this->byteOrder, $this->reader->readBytes($total * 4));
     }
 
diff --git a/src/lib/parquet/src/Flow/Parquet/Data/PlainValuesPacker.php b/src/lib/parquet/src/Flow/Parquet/Data/PlainValuesPacker.php
index f16832915e..d41c05d9fe 100644
--- a/src/lib/parquet/src/Flow/Parquet/Data/PlainValuesPacker.php
+++ b/src/lib/parquet/src/Flow/Parquet/Data/PlainValuesPacker.php
@@ -12,15 +12,11 @@
 use RuntimeException;
 
 use function array_filter;
-use function array_map;
-use function Flow\Parquet\Binary\encode_decimal;
 use function Flow\Parquet\Binary\encode_f32;
 use function Flow\Parquet\Binary\encode_f64;
 use function Flow\Parquet\Binary\encode_i32;
 use function Flow\Parquet\Binary\encode_i64;
 use function Flow\Parquet\Binary\encode_u32;
-use function hex2bin;
-use function str_replace;
 use function strlen;
 
 final readonly class PlainValuesPacker
@@ -64,28 +60,8 @@ public function packValues(FlatColumn $column, array $values): void
 
                 break;
             case PhysicalType::FIXED_LEN_BYTE_ARRAY:
-                switch ($column->logicalType()?->name()) {
-                    case LogicalType::UUID:
-                        /** @var array<string> $values */
-                        $this->packUuids($values);
-
-                        break;
-                    case LogicalType::DECIMAL:
-                        /** @var array<float> $values */
-                        $this->packDecimals(
-                            $values,
-                            (int) $column->typeLength(),
-                            (int) $column->logicalType()?->decimalData()?->precision(),
-                            (int) $column->logicalType()?->decimalData()?->scale(),
-                        );
-
-                        break;
-                    default:
-                        /** @var array<string> $values */
-                        $this->packFixedLenByteArrays($values);
-
-                        break;
-                }
+                /** @var array<string> $values */
+                $this->packFixedLenByteArrays($values);
 
                 break;
             case PhysicalType::BYTE_ARRAY:
@@ -95,19 +71,6 @@ public function packValues(FlatColumn $column, array $values): void
                         /** @var array<string> $values */
                         $this->packStrings($values);
 
-                        break;
-                    case LogicalType::DECIMAL:
-                        $precision = (int) $column->logicalType()?->decimalData()?->precision();
-                        $scale = (int) $column->logicalType()?->decimalData()?->scale();
-
-                        /** @var array<float|int> $values */
-                        $this->packByteArrays(array_map(static fn(float|int $value): string => encode_decimal(
-                            (float) $value,
-                            $precision,
-                            $scale,
-                            null,
-                        ), $values));
-
                         break;
                     default:
                         /** @var array<string> $values */
@@ -149,16 +112,6 @@ private function packByteArrays(array $values): void
         }
     }
 
-    /**
-     * @param array<float> $decimals
-     */
-    private function packDecimals(array $decimals, int $byteLength, int $precision, int $scale): void
-    {
-        foreach ($decimals as $decimal) {
-            $this->writer->append(encode_decimal($decimal, $precision, $scale, $byteLength));
-        }
-    }
-
     /**
      * @param array<float> $doubles
      */
@@ -211,21 +164,4 @@ private function packStrings(array $strings): void
             $this->writer->append($string);
         }
     }
-
-    /**
-     * @param array<string> $uuids
-     */
-    private function packUuids(array $uuids): void
-    {
-        foreach ($uuids as $uuid) {
-            $hex = str_replace('-', '', $uuid);
-            $binary = hex2bin($hex);
-
-            if ($binary === false) {
-                throw new RuntimeException('Invalid UUID format: ' . $uuid);
-            }
-
-            $this->writer->append($binary);
-        }
-    }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Dremel/ColumnData/ReadFlatColumnValues.php b/src/lib/parquet/src/Flow/Parquet/Dremel/ColumnData/ReadFlatColumnValues.php
index 4ad23baee3..406d2ea834 100644
--- a/src/lib/parquet/src/Flow/Parquet/Dremel/ColumnData/ReadFlatColumnValues.php
+++ b/src/lib/parquet/src/Flow/Parquet/Dremel/ColumnData/ReadFlatColumnValues.php
@@ -4,14 +4,19 @@
 
 namespace Flow\Parquet\Dremel\ColumnData;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\Data\DataConverter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader\RowSelection;
 use Generator;
 
 use function count;
+use function sprintf;
 
 final readonly class ReadFlatColumnValues
 {
+    private int $rowsCount;
+
     /**
      * @param FlatColumn $column
      * @param \Generator<mixed, mixed, mixed, mixed> $values
@@ -23,7 +28,15 @@ public function __construct(
         private Generator $values,
         private array $repetitionLevels,
         private array $definitionLevels,
-    ) {}
+    ) {
+        $rowsCount = 0;
+
+        foreach ($repetitionLevels as $repetitionLevel) {
+            $rowsCount += $repetitionLevel === 0 ? 1 : 0;
+        }
+
+        $this->rowsCount = $rowsCount;
+    }
 
     /**
      * @return \Generator<array-key, mixed>
@@ -100,16 +113,68 @@ public function repetitionLevels(): array
         return $this->repetitionLevels;
     }
 
-    public function rowsCount(): int
+    /**
+     * The rows $rows selects, its row 0 being this page's first row; a row starts at each repetition level 0.
+     */
+    public function select(RowSelection $rows): self
     {
-        $rowsCount = 0;
+        if ($rows->totalRows() !== $this->rowsCount()) {
+            throw new InvalidArgumentException(sprintf(
+                'A selection of %d rows cannot select from a page of %d rows',
+                $rows->totalRows(),
+                $this->rowsCount(),
+            ));
+        }
 
-        foreach ($this->repetitionLevels as $repetitionLevel) {
+        $maxDefinitionLevel = $this->column->repetitions()->maxDefinitionLevel();
+        $selectors = $rows->selectors();
+        $selector = -1;
+        $remaining = 0;
+        $skip = true;
+        $repetitionLevels = [];
+        $definitionLevels = [];
+        $keptValues = [];
+
+        foreach ($this->repetitionLevels as $index => $repetitionLevel) {
             if ($repetitionLevel === 0) {
-                $rowsCount++;
+                if ($remaining === 0) {
+                    $remaining = $selectors[++$selector]->rowCount;
+                }
+
+                $remaining--;
+                $skip = $selectors[$selector]->skip;
+            }
+
+            if ($this->definitionLevels[$index] === $maxDefinitionLevel) {
+                $keptValues[] = !$skip;
+            }
+
+            if (!$skip) {
+                $repetitionLevels[] = $repetitionLevel;
+                $definitionLevels[] = $this->definitionLevels[$index];
             }
         }
 
-        return $rowsCount;
+        $values = $this->values;
+
+        return new self(
+            $this->column,
+            (static function () use ($values, $keptValues): Generator {
+                foreach ($keptValues as $kept) {
+                    if ($kept) {
+                        yield $values->current();
+                    }
+
+                    $values->next();
+                }
+            })(),
+            $repetitionLevels,
+            $definitionLevels,
+        );
+    }
+
+    public function rowsCount(): int
+    {
+        return $this->rowsCount;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Dremel/RowGroupContainer.php b/src/lib/parquet/src/Flow/Parquet/Dremel/RowGroupContainer.php
index 5f591779f4..4ee96fa406 100644
--- a/src/lib/parquet/src/Flow/Parquet/Dremel/RowGroupContainer.php
+++ b/src/lib/parquet/src/Flow/Parquet/Dremel/RowGroupContainer.php
@@ -4,12 +4,20 @@
 
 namespace Flow\Parquet\Dremel;
 
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
 use Flow\Parquet\ParquetFile\RowGroup;
 
 final readonly class RowGroupContainer
 {
+    /**
+     * @param list<?ColumnIndex> $columnIndexes one per column chunk of the row group, in order
+     * @param list<OffsetIndex> $offsetIndexes one per column chunk of the row group, in order
+     */
     public function __construct(
         public string $binaryBuffer,
         public RowGroup $rowGroup,
+        public array $columnIndexes,
+        public array $offsetIndexes,
     ) {}
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Dremel/Statistics/Comparator.php b/src/lib/parquet/src/Flow/Parquet/Dremel/Statistics/Comparator.php
deleted file mode 100644
index 478aa06e14..0000000000
--- a/src/lib/parquet/src/Flow/Parquet/Dremel/Statistics/Comparator.php
+++ /dev/null
@@ -1,77 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Flow\Parquet\Dremel\Statistics;
-
-use DateInterval;
-use Flow\Parquet\ParquetFile\Data\Converter\TimeConverter;
-use Flow\Parquet\ParquetFile\Schema\TimeUnit;
-use RuntimeException;
-
-use function gettype;
-use function is_scalar;
-use function sprintf;
-
-final class Comparator
-{
-    public function isGreaterThan(mixed $value, mixed $nextValue): bool
-    {
-        if ($value === null) {
-            return false;
-        }
-
-        if ($nextValue === null) {
-            return true;
-        }
-
-        if (gettype($value) !== gettype($nextValue)) {
-            throw new RuntimeException(sprintf('Cannot compare %s with %s', gettype($value), gettype($nextValue)));
-        }
-
-        if ($value instanceof DateInterval) {
-            $value = (new TimeConverter(TimeUnit::MICROSECONDS))->toParquetType($value);
-            $nextValue = (new TimeConverter(TimeUnit::MICROSECONDS))->toParquetType($nextValue);
-        }
-
-        if (!is_scalar($value) || !is_scalar($nextValue)) {
-            throw new RuntimeException(sprintf(
-                'Cannot compare non-scalar values: %s with %s',
-                gettype($value),
-                gettype($nextValue),
-            ));
-        }
-
-        return $value > $nextValue;
-    }
-
-    public function isLessThan(mixed $value, mixed $nextValue): bool
-    {
-        if ($value === null) {
-            return false;
-        }
-
-        if ($nextValue === null) {
-            return true;
-        }
-
-        if (gettype($value) !== gettype($nextValue)) {
-            throw new RuntimeException(sprintf('Cannot compare %s with %s', gettype($value), gettype($nextValue)));
-        }
-
-        if ($value instanceof DateInterval) {
-            $value = (new TimeConverter(TimeUnit::MICROSECONDS))->toParquetType($value);
-            $nextValue = (new TimeConverter(TimeUnit::MICROSECONDS))->toParquetType($nextValue);
-        }
-
-        if (!is_scalar($value) || !is_scalar($nextValue)) {
-            throw new RuntimeException(sprintf(
-                'Cannot compare non-scalar values: %s with %s',
-                gettype($value),
-                gettype($nextValue),
-            ));
-        }
-
-        return $value < $nextValue;
-    }
-}
diff --git a/src/lib/parquet/src/Flow/Parquet/Dremel/Validator/ColumnDataValidator.php b/src/lib/parquet/src/Flow/Parquet/Dremel/Validator/ColumnDataValidator.php
index 3832480490..4c6392cc94 100644
--- a/src/lib/parquet/src/Flow/Parquet/Dremel/Validator/ColumnDataValidator.php
+++ b/src/lib/parquet/src/Flow/Parquet/Dremel/Validator/ColumnDataValidator.php
@@ -8,6 +8,7 @@
 use DateTimeInterface;
 use Flow\Parquet\Dremel\Validator;
 use Flow\Parquet\Exception\ValidationException;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt64Converter;
 use Flow\Parquet\ParquetFile\Schema\Column;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
@@ -142,6 +143,21 @@ private function validateData(FlatColumn $column, mixed $data, ?Repetition $repe
 
         $type = $column->type();
         $logicalTypeName = $column->logicalType()?->name();
+        $integer = Integer::forColumn($column);
+
+        if ($type === PhysicalType::INT64 && $integer?->is(64, false) === true) {
+            if (!UnsignedInt64Converter::accepts($data)) {
+                throw new ValidationException(sprintf(
+                    'Column "%s" row %d: %s is out of the UINT_64 range [0, %s]',
+                    $column->flatPath(),
+                    $row,
+                    is_int($data) || is_string($data) ? $data : get_debug_type($data),
+                    UnsignedInt64Converter::MAX,
+                ));
+            }
+
+            return;
+        }
 
         match ($type) {
             PhysicalType::BOOLEAN => is_bool($data)
@@ -187,7 +203,6 @@ private function validateData(FlatColumn $column, mixed $data, ?Repetition $repe
         };
 
         if (is_int($data) && ($type === PhysicalType::INT32 || $type === PhysicalType::INT64)) {
-            $integer = Integer::forColumn($column);
             [$name, $min, $max] = match (true) {
                 $integer === null && $type === PhysicalType::INT32 && $column->logicalType() === null => [
                     'INT32',
@@ -200,11 +215,7 @@ private function validateData(FlatColumn $column, mixed $data, ?Repetition $repe
                     $integer->bitWidth() === 64 ? PHP_INT_MIN : -(1 << ($integer->bitWidth() - 1)),
                     $integer->bitWidth() === 64 ? PHP_INT_MAX : (1 << ($integer->bitWidth() - 1)) - 1,
                 ],
-                default => [
-                    'UINT_' . $integer->bitWidth(),
-                    0,
-                    $integer->bitWidth() === 64 ? PHP_INT_MAX : (1 << $integer->bitWidth()) - 1,
-                ],
+                default => ['UINT_' . $integer->bitWidth(), 0, (1 << $integer->bitWidth()) - 1],
             };
 
             if ($data < $min || $data > $max) {
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/OptionsConverter.php b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/OptionsConverter.php
index 7316773cdc..d6fc62f42f 100644
--- a/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/OptionsConverter.php
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/OptionsConverter.php
@@ -4,10 +4,14 @@
 
 namespace Flow\Parquet\Engine\Arrow;
 
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\Writer\StatisticsLevel;
+
+use function array_map;
 
 final class OptionsConverter
 {
@@ -36,14 +40,17 @@ public static function toExtension(Options $options): array
         $result = [];
 
         $mappings = [
-            [Option::ARROW_BATCH_SIZE,         'BATCH_SIZE'],
-            [Option::GZIP_COMPRESSION_LEVEL,   'GZIP_COMPRESSION_LEVEL'],
-            [Option::BROTLI_COMPRESSION_LEVEL, 'BROTLI_COMPRESSION_LEVEL'],
-            [Option::ZSTD_COMPRESSION_LEVEL,   'ZSTD_COMPRESSION_LEVEL'],
-            [Option::ROW_GROUP_SIZE_BYTES,     'ROW_GROUP_SIZE_BYTES'],
-            [Option::PAGE_SIZE_BYTES,          'PAGE_SIZE_BYTES'],
-            [Option::DICTIONARY_PAGE_SIZE,     'DICTIONARY_PAGE_SIZE'],
-            [Option::WRITER_VERSION,           'WRITER_VERSION'],
+            [Option::GZIP_COMPRESSION_LEVEL,       'GZIP_COMPRESSION_LEVEL'],
+            [Option::BROTLI_COMPRESSION_LEVEL,     'BROTLI_COMPRESSION_LEVEL'],
+            [Option::ZSTD_COMPRESSION_LEVEL,       'ZSTD_COMPRESSION_LEVEL'],
+            [Option::ROW_GROUP_SIZE_BYTES,         'ROW_GROUP_SIZE_BYTES'],
+            [Option::PAGE_SIZE_BYTES,              'PAGE_SIZE_BYTES'],
+            [Option::PAGE_MAXIMUM_ROWS_COUNT,      'PAGE_MAXIMUM_ROWS_COUNT'],
+            [Option::DICTIONARY_PAGE_SIZE,         'DICTIONARY_PAGE_SIZE'],
+            [Option::WRITER_VERSION,               'WRITER_VERSION'],
+            [Option::STATISTICS_TRUNCATE_LENGTH,   'STATISTICS_TRUNCATE_LENGTH'],
+            [Option::COLUMN_INDEX_TRUNCATE_LENGTH, 'COLUMN_INDEX_TRUNCATE_LENGTH'],
+            [Option::PAGE_HEADER_STATISTICS,       'PAGE_HEADER_STATISTICS'],
         ];
 
         foreach ($mappings as [$option, $extensionKey]) {
@@ -54,6 +61,8 @@ public static function toExtension(Options $options): array
             }
         }
 
+        $result['STATISTICS_LEVEL'] = $options->getEnum(Option::STATISTICS_LEVEL, StatisticsLevel::class)->name;
+
         $columnsCompressions = $options->getArray(Option::COLUMNS_COMPRESSIONS);
 
         if ($columnsCompressions !== null) {
@@ -89,6 +98,15 @@ public static function toExtension(Options $options): array
             }
         }
 
+        $bloomFilters = BloomFilterOptions::forColumns($options);
+
+        if ($bloomFilters !== []) {
+            $result['COLUMNS_BLOOM_FILTERS'] = array_map(static fn(BloomFilterOptions $bloomFilter): array => [
+                'fpp' => $bloomFilter->fpp,
+                'ndv' => $bloomFilter->ndv,
+            ], $bloomFilters);
+        }
+
         return $result;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/ReadPlanConverter.php b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/ReadPlanConverter.php
new file mode 100644
index 0000000000..4fdf023b5e
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/ReadPlanConverter.php
@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Engine\Arrow;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Binding\AbsentLeaf;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\FilterVisitor;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\StartsWith;
+use Flow\Parquet\Reader\ReadPlan;
+
+use function array_map;
+
+/**
+ * @implements FilterVisitor<array<string, mixed>>
+ */
+final readonly class ReadPlanConverter implements FilterVisitor
+{
+    private function __construct(
+        private BoundFilter $filter,
+    ) {}
+
+    /**
+     * Called by name from arrow-ext RustBatchReader::__construct() and RustColumnsReader::__construct(), pinned by
+     * phpt 055.
+     *
+     * @return array{selectors: list<array{0: int, 1: bool}>, filter?: array<string, mixed>, limit: ?int} file-absolute
+     *         selectors (row count, skip), the row filter's tree and the limit counted after it
+     */
+    public static function toExtension(ReadPlan $plan): array
+    {
+        $converted = [
+            'selectors' => array_map(static fn($selector): array => [
+                $selector->rowCount,
+                $selector->skip,
+            ], $plan->selection->selectors()),
+        ];
+
+        if ($plan->rowFilter !== null) {
+            $converted['filter'] = $plan->rowFilter->filter()->accept(new self($plan->rowFilter));
+        }
+
+        $converted['limit'] = $plan->limit;
+
+        return $converted;
+    }
+
+    public function all(All $all): array
+    {
+        return ['and' => $this->children($all->filters)];
+    }
+
+    public function any(Any $any): array
+    {
+        return ['or' => $this->children($any->filters)];
+    }
+
+    public function comparison(Comparison $comparison): array
+    {
+        return $this->intervals($comparison);
+    }
+
+    public function in(In $in): array
+    {
+        return $this->intervals($in);
+    }
+
+    public function isNull(IsNull $isNull): array
+    {
+        $resolution = $this->filter->rowLeaf($isNull);
+
+        return (
+            $resolution instanceof AbsentLeaf
+                ? ['leaf' => 'absent', 'is_null' => true]
+                : ['leaf' => 'is_null', 'path' => $resolution->column->path()]
+        );
+    }
+
+    public function not(Not $not): array
+    {
+        return ['not' => $not->filter->accept($this)];
+    }
+
+    public function startsWith(StartsWith $startsWith): array
+    {
+        $resolution = $this->filter->rowLeaf($startsWith);
+
+        return (
+            $resolution instanceof AbsentLeaf
+                ? ['leaf' => 'absent', 'is_null' => false]
+                : ['leaf' => 'starts_with', 'path' => $resolution->column->path(), 'prefix' => $startsWith->prefix]
+        );
+    }
+
+    /**
+     * @param list<Filter> $filters
+     *
+     * @return list<array<string, mixed>>
+     */
+    private function children(array $filters): array
+    {
+        return array_map(fn(Filter $child): array => $child->accept($this), $filters);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function intervals(Comparison|In $node): array
+    {
+        $resolution = $this->filter->rowLeaf($node);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return ['leaf' => 'absent', 'is_null' => false];
+        }
+
+        /** @var PhysicalIntervals $intervals rowLeaf() resolves only leaves answered exactly */
+        $intervals = $resolution->intervals;
+
+        return [
+            'leaf' => 'intervals',
+            'path' => $resolution->column->path(),
+            'intervals' => array_map(static fn($interval): array => [
+                $interval->lower,
+                $interval->lowerInclusive,
+                $interval->upper,
+                $interval->upperInclusive,
+            ], $intervals->intervals),
+        ];
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/RustRowGroupChunks.php b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/RustRowGroupChunks.php
new file mode 100644
index 0000000000..4a83194177
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/RustRowGroupChunks.php
@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Engine\Arrow;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Exception\OutOfBoundsException;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
+use Flow\Parquet\ThriftModel\ColumnChunk as ThriftColumnChunk;
+use Flow\Parquet\ThriftModel\ColumnOrder as ThriftColumnOrder;
+
+use function array_key_exists;
+
+final class RustRowGroupChunks implements RowGroupChunks
+{
+    /**
+     * @var array<string, array<int, ColumnChunk>>
+     */
+    private array $decoded = [];
+
+    /**
+     * @var array<string, ColumnOrder>
+     */
+    private array $decodedOrders = [];
+
+    /**
+     * @param list<int> $rowCounts
+     * @param array<string, list<string>> $chunks thrift ColumnChunk bytes per flat path, one per row group
+     * @param array<string, null|string> $orders thrift ColumnOrder bytes per flat path, null without column_orders
+     */
+    private function __construct(
+        private readonly array $rowCounts,
+        private readonly array $chunks,
+        private readonly array $orders,
+    ) {}
+
+    /**
+     * Called by name from arrow-ext RustParquetFooter::rowGroupChunks(), pinned by phpt 056.
+     *
+     * @param list<int> $rowCounts
+     * @param array<string, list<string>> $chunks
+     * @param array<string, null|string> $orders
+     */
+    public static function fromThrift(array $rowCounts, array $chunks, array $orders): self
+    {
+        return new self($rowCounts, $chunks, $orders);
+    }
+
+    public function chunk(int $rowGroup, FlatColumn $column): ColumnChunk
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($path, $this->chunks)) {
+            throw new InvalidArgumentException('Column "' . $path . '" was not read from the footer');
+        }
+
+        if (!array_key_exists($rowGroup, $this->chunks[$path])) {
+            throw new OutOfBoundsException('Row group ' . $rowGroup . ' does not exist');
+        }
+
+        if (!array_key_exists($rowGroup, $this->decoded[$path] ?? [])) {
+            $thrift = new ThriftColumnChunk();
+            $thrift->read(new CompactProtocol(new MemoryBuffer($this->chunks[$path][$rowGroup])));
+            $this->decoded[$path][$rowGroup] = ColumnChunk::fromThrift($thrift);
+        }
+
+        return $this->decoded[$path][$rowGroup];
+    }
+
+    public function columnOrder(FlatColumn $column): ColumnOrder
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($path, $this->orders)) {
+            throw new InvalidArgumentException('Column "' . $path . '" was not read from the footer');
+        }
+
+        if ($this->orders[$path] === null) {
+            return ColumnOrder::Absent;
+        }
+
+        if (!array_key_exists($path, $this->decodedOrders)) {
+            $thrift = new ThriftColumnOrder();
+            $thrift->read(new CompactProtocol(new MemoryBuffer($this->orders[$path])));
+            $this->decodedOrders[$path] = ColumnOrder::fromThrift($thrift);
+        }
+
+        return $this->decodedOrders[$path];
+    }
+
+    public function rowCounts(): array
+    {
+        return $this->rowCounts;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/SchemaConverter.php b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/SchemaConverter.php
index 2004d1a185..00a3f59fa0 100644
--- a/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/SchemaConverter.php
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/Arrow/SchemaConverter.php
@@ -135,7 +135,7 @@ private static function resolveFlatType(FlatColumn $column): string
                 LogicalType::DECIMAL => 'DECIMAL',
                 LogicalType::UUID => 'UUID',
                 LogicalType::JSON => 'JSON',
-                LogicalType::ENUM => 'STRING',
+                LogicalType::ENUM => 'ENUM',
                 LogicalType::BSON => 'BINARY',
                 LogicalType::INTEGER => self::resolveIntegerType($column),
                 default => self::resolveFromConvertedOrPhysical($column),
@@ -157,7 +157,7 @@ private static function resolveFromConvertedOrPhysical(FlatColumn $column): stri
                 ConvertedType::TIME_MILLIS, ConvertedType::TIME_MICROS => 'TIME',
                 ConvertedType::DECIMAL => 'DECIMAL',
                 ConvertedType::JSON => 'JSON',
-                ConvertedType::ENUM => 'STRING',
+                ConvertedType::ENUM => 'ENUM',
                 ConvertedType::BSON => 'BINARY',
                 ConvertedType::INT_8,
                 ConvertedType::INT_16,
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/ArrowExtension.php b/src/lib/parquet/src/Flow/Parquet/Engine/ArrowExtension.php
index bf9ed403e4..d2ce7a9920 100644
--- a/src/lib/parquet/src/Flow/Parquet/Engine/ArrowExtension.php
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/ArrowExtension.php
@@ -16,9 +16,9 @@
 {
     /**
      * The contract version this package expects from arrow-ext, equal to the extension's FLOW_ARROW_ABI. Both sides
-     * change together whenever a class or interface the extension registers changes.
+     * change together whenever a registered class or interface, or the schema, options or values crossing them, change.
      */
-    public const int ABI = 1;
+    public const int ABI = 2;
 
     public function __construct(
         public bool $loaded,
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileReader.php b/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileReader.php
index 76d0f74c38..78e70b88a3 100644
--- a/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileReader.php
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileReader.php
@@ -9,28 +9,33 @@
 use Flow\Parquet\Dremel\DremelAssembler;
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\Filter\Evaluation\RowEvaluator;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile;
 use Flow\Parquet\ParquetFile\Data\DataConverter;
-use Flow\Parquet\ParquetFile\Metadata;
-use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\RowGroup;
 use Flow\Parquet\ParquetFileReader;
 use Flow\Parquet\Reader\ColumnChunkReader;
 use Flow\Parquet\Reader\ColumnReader;
 use Flow\Parquet\Reader\PageReader;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\SelectedPages;
 use Flow\Parquet\Thrift\CompactProtocol;
 use Flow\Parquet\Thrift\MemoryBuffer;
 use Flow\Parquet\ThriftModel\FileMetaData;
 use Generator;
 
-use function count;
+use function array_fill_keys;
+use function array_map;
+use function array_values;
 use function is_array;
 use function min;
+use function sprintf;
 use function unpack;
 
 final class PhpParquetFileReader implements ParquetFileReader
 {
-    private ?Metadata $metadata = null;
+    private ?PhpParquetFooter $footer = null;
 
     private bool $open = true;
 
@@ -48,12 +53,12 @@ public function close(): void
         $this->stream->close();
     }
 
-    public function metadata(): Metadata
+    public function footer(): PhpParquetFooter
     {
         $this->open || throw new RuntimeException('Reader is not open');
 
-        if ($this->metadata !== null) {
-            return $this->metadata;
+        if ($this->footer !== null) {
+            return $this->footer;
         }
 
         $fileTotalSize = $this->stream->size();
@@ -83,115 +88,168 @@ public function metadata(): Metadata
         $thriftMetadata = new FileMetaData();
         $thriftMetadata->read(new CompactProtocol(new MemoryBuffer($metadata)));
 
-        $this->metadata = Metadata::fromThrift($thriftMetadata);
+        $this->footer = new PhpParquetFooter($thriftMetadata);
 
-        return $this->metadata;
+        return $this->footer;
     }
 
     /**
      * @param list<string> $columns
-     * @param int<1, max> $batchSize
+     * @param int $batchSize refused below 1, as the arrow engine refuses it
      *
      * @return Generator<int, array<string, list<mixed>>>
      */
-    public function readColumns(array $columns, int $batchSize, ?int $limit, ?int $offset): Generator
+    public function readColumns(array $columns, int $batchSize, ReadPlan $plan): Generator
     {
         $this->open || throw new RuntimeException('Reader is not open');
 
+        if ($batchSize < 1) {
+            throw new InvalidArgumentException('Parquet batch size must be greater than 0');
+        }
+
+        $metadata = $this->footer()->metadata();
+
+        foreach ($columns as $columnName) {
+            if (!$metadata->schema()->has($columnName)) {
+                throw new InvalidArgumentException('Parquet file has no column "' . $columnName . '"');
+            }
+        }
+
         $columnReader = new ColumnReader(
-            new ColumnChunkReader(new PageReader($this->byteOrder, $this->options), $this->options),
+            new SelectedPages(new ColumnChunkReader(new PageReader($this->byteOrder, $this->options), $this->options)),
             new DremelAssembler(DataConverter::initialize($this->options)),
         );
 
-        $metadata = $this->metadata();
-
-        $totalRows = $metadata->rowsNumber();
+        if ($plan->selection->totalRows() !== $metadata->rowsNumber()) {
+            throw new InvalidArgumentException(sprintf(
+                'A read plan over %d rows cannot read a file of %d rows',
+                $plan->selection->totalRows(),
+                $metadata->rowsNumber(),
+            ));
+        }
 
-        if ($offset !== null && $offset > $totalRows) {
+        if ($columns === [] || !$plan->selection->selectsAny() || $plan->limit === 0) {
             return;
         }
 
-        if ($offset !== null) {
-            if ($totalRows > $offset) {
-                $totalRows -= $offset;
-            } else {
-                $totalRows = 0;
+        $rowGroups = array_values($metadata->rowGroups()->all());
+        $rowCounts = array_map(static fn(RowGroup $rowGroup): int => $rowGroup->rowsCount(), $rowGroups);
+        $selections = $plan->selection->split($rowCounts);
+        $matches = $plan->matched->split($rowCounts);
+        $remaining = $plan->limit;
+        $batch = array_fill_keys($columns, []);
+        $batched = 0;
+
+        foreach ($rowGroups as $group => $rowGroup) {
+            $selection = $selections[$group];
+
+            if (!$selection->selectsAny()) {
+                continue;
             }
-        }
 
-        $totalRows = min($totalRows, $limit ?? $totalRows);
+            $decoded = [];
 
-        if ($totalRows === 0) {
-            return;
-        }
+            if ($plan->rowFilter !== null) {
+                $unmatched = $selection->difference($matches[$group]);
 
-        $generators = [];
+                if ($unmatched->selectsAny()) {
+                    $physical = [];
 
-        foreach ($columns as $columnName) {
-            $generators[$columnName] = $columnReader->read(
-                $metadata->schema()->get($columnName),
-                $metadata,
-                $this->stream,
-                $limit,
-                $offset,
-            );
-        }
+                    foreach ($plan->rowFilter->columns() as $leaf) {
+                        ['chunk' => $decoded[$leaf->flatPath()], 'values' => $physical[$leaf->flatPath()]] =
+                            $columnReader->readPhysical(
+                                $leaf,
+                                $rowGroup,
+                                $group,
+                                $this->stream,
+                                $unmatched,
+                                $plan->indexes,
+                            );
+                    }
 
-        $remaining = $totalRows;
+                    $selection = $matches[$group]->union($unmatched->masked(RowEvaluator::evaluate(
+                        $plan->rowFilter,
+                        $physical,
+                        $unmatched->rowCount(),
+                    )));
+                }
+            }
 
-        while ($remaining > 0) {
-            $take = min($batchSize, $remaining);
-            $chunk = [];
-            $read = 0;
+            $rows = $selection->rowCount();
 
-            foreach ($generators as $name => $generator) {
-                $values = [];
+            if ($remaining !== null && $rows > $remaining) {
+                $selection = $selection->head($remaining);
+                $rows = $remaining;
+            }
 
-                while (count($values) < $take && $generator->valid()) {
-                    // @mago-ignore analysis:mixed-assignment
-                    $entry = $generator->current();
+            if ($rows === 0) {
+                continue;
+            }
 
-                    if (is_array($entry)) {
+            $generators = [];
+
+            foreach ($columns as $columnName) {
+                $generators[$columnName] = $columnReader->readRowGroup(
+                    $metadata->schema()->get($columnName),
+                    $rowGroup,
+                    $group,
+                    $this->stream,
+                    $selection,
+                    $plan->indexes,
+                    $decoded,
+                );
+            }
+
+            $left = $rows;
+
+            while ($left > 0) {
+                $take = min($batchSize - $batched, $left);
+
+                foreach ($generators as $name => $generator) {
+                    for ($taken = 0; $taken < $take && $generator->valid(); $taken++) {
                         // @mago-ignore analysis:mixed-assignment
-                        foreach ($entry as $value) {
-                            $values[] = $value;
+                        $entry = $generator->current();
+
+                        if (is_array($entry)) {
+                            // @mago-ignore analysis:mixed-assignment
+                            foreach ($entry as $value) {
+                                $batch[$name][] = $value;
+                            }
                         }
+
+                        $generator->next();
                     }
 
-                    $generator->next();
+                    if ($taken < $take) {
+                        throw new RuntimeException(sprintf(
+                            'Column "%s" decodes fewer rows of row group %d than its metadata declares',
+                            $name,
+                            $group,
+                        ));
+                    }
                 }
 
-                $chunk[$name] = $values;
-                $read = count($values);
-            }
+                $batched += $take;
+                $left -= $take;
 
-            if ($read === 0) {
-                return;
+                if ($batched === $batchSize) {
+                    yield $batch;
+                    $batch = array_fill_keys($columns, []);
+                    $batched = 0;
+                }
             }
 
-            yield $chunk;
-            $remaining -= $read;
-        }
-    }
+            if ($remaining !== null) {
+                $remaining -= $rows;
 
-    public function rowsNumber(): int
-    {
-        return $this->metadata()->rowsNumber();
-    }
-
-    public function schema(): Schema
-    {
-        return $this->metadata()->schema();
-    }
-
-    public function totalByteSize(): int
-    {
-        $bytes = 0;
-
-        foreach ($this->metadata()->rowGroups()->all() as $rowGroup) {
-            $bytes += $rowGroup->totalByteSize();
+                if ($remaining === 0) {
+                    break;
+                }
+            }
         }
 
-        return $bytes;
+        if ($batched > 0) {
+            yield $batch;
+        }
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileWriter.php b/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileWriter.php
index 5dab604466..a63638b4f9 100644
--- a/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileWriter.php
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFileWriter.php
@@ -13,19 +13,29 @@
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile;
+use Flow\Parquet\ParquetFile\ColumnOrder;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Index\IndexLocation;
 use Flow\Parquet\ParquetFile\Metadata;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\RowGroup;
 use Flow\Parquet\ParquetFile\RowGroups;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFileWriter;
 use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
 use Flow\Parquet\Thrift\PhpFileStream;
+use Flow\Parquet\ThriftModel\ColumnIndex as ThriftColumnIndex;
+use Flow\Parquet\ThriftModel\OffsetIndex as ThriftOffsetIndex;
 use Flow\Parquet\Writer\ColumnLists;
 use Flow\Parquet\Writer\RowGroupBuilder;
 
 use function array_chunk;
+use function array_map;
 use function array_slice;
+use function array_values;
 use function fclose;
 use function fopen;
 use function is_array;
@@ -43,6 +53,23 @@ final class PhpParquetFileWriter implements ParquetFileWriter
 
     private readonly RowGroupBuilder $rowGroupBuilder;
 
+    /**
+     * @var list<list<?ColumnIndex>>
+     */
+    private array $columnIndexes = [];
+
+    /**
+     * @var list<list<OffsetIndex>>
+     */
+    private array $offsetIndexes = [];
+
+    /**
+     * Written row groups, added to the metadata once their page indexes are written after the last of them.
+     *
+     * @var list<RowGroup>
+     */
+    private array $rowGroups = [];
+
     private ?DestinationStream $stream;
 
     public function __construct(
@@ -61,6 +88,7 @@ public function __construct(
             0,
             $options->getInt(Option::WRITER_VERSION),
             'flow-php parquet version ' . InstalledVersions::getRootPackage()['pretty_version'],
+            array_map(ColumnOrder::forWriting(...), array_values($schema->columnsFlat())),
         );
         $this->rowGroupBuilder = new RowGroupBuilder(
             $schema,
@@ -82,6 +110,8 @@ public function close(): void
                 $this->flushRowGroup($stream);
             }
 
+            $this->writePageIndexes($stream);
+
             $metadataHandle = fopen('php://temp/maxmemory:' . (5 * 1024 * 1024), 'rb+');
 
             if ($metadataHandle === false) {
@@ -171,7 +201,57 @@ private function flushRowGroup(DestinationStream $stream): void
     {
         $rowGroupContainer = $this->rowGroupBuilder->flush($this->fileOffset);
         $stream->append($rowGroupContainer->binaryBuffer);
-        $this->metadata->rowGroups()->add($rowGroupContainer->rowGroup);
+        $this->rowGroups[] = $rowGroupContainer->rowGroup;
+        $this->columnIndexes[] = $rowGroupContainer->columnIndexes;
+        $this->offsetIndexes[] = $rowGroupContainer->offsetIndexes;
         $this->fileOffset += strlen($rowGroupContainer->binaryBuffer);
     }
+
+    /**
+     * Every column index, then every offset index, between the last row group and the footer (parquet.thrift
+     * PageIndex layout); each chunk is given its indexes' locations.
+     */
+    private function writePageIndexes(DestinationStream $stream): void
+    {
+        $columnIndexLocations = [];
+        $offsetIndexLocations = [];
+
+        foreach ($this->columnIndexes as $rowGroup => $columnIndexes) {
+            foreach ($columnIndexes as $chunk => $columnIndex) {
+                $columnIndexLocations[$rowGroup][$chunk] = $columnIndex === null
+                    ? null
+                    : $this->writeThrift($stream, $columnIndex->toThrift());
+            }
+        }
+
+        foreach ($this->offsetIndexes as $rowGroup => $offsetIndexes) {
+            foreach ($offsetIndexes as $chunk => $offsetIndex) {
+                $offsetIndexLocations[$rowGroup][$chunk] = $this->writeThrift($stream, $offsetIndex->toThrift());
+            }
+        }
+
+        foreach ($this->rowGroups as $rowGroup => $group) {
+            $chunks = [];
+
+            foreach (array_values($group->columnChunks()) as $chunk => $columnChunk) {
+                $chunks[] = $columnChunk->withLocations(
+                    columnIndex: $columnIndexLocations[$rowGroup][$chunk] ?? null,
+                    offsetIndex: $offsetIndexLocations[$rowGroup][$chunk],
+                );
+            }
+
+            $this->metadata->rowGroups()->add(new RowGroup($chunks, $group->rowsCount()));
+        }
+    }
+
+    private function writeThrift(DestinationStream $stream, ThriftColumnIndex|ThriftOffsetIndex $struct): IndexLocation
+    {
+        $struct->write(new CompactProtocol($buffer = new MemoryBuffer()));
+        $bytes = $buffer->data();
+        $stream->append($bytes);
+        $location = new IndexLocation($this->fileOffset, strlen($bytes));
+        $this->fileOffset += strlen($bytes);
+
+        return $location;
+    }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFooter.php b/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFooter.php
new file mode 100644
index 0000000000..eb90e189fd
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Engine/PhpParquetFooter.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Engine;
+
+use Flow\Parquet\ParquetFile\Footer;
+use Flow\Parquet\ParquetFile\Metadata;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ThriftModel\FileMetaData;
+
+final class PhpParquetFooter implements Footer
+{
+    private ?Metadata $metadata = null;
+
+    public function __construct(
+        private readonly FileMetaData $thrift,
+    ) {}
+
+    public function metadata(): Metadata
+    {
+        return $this->metadata ??= Metadata::fromThrift($this->thrift);
+    }
+
+    public function rowGroupChunks(array $columns): RowGroupChunks
+    {
+        return new MetadataRowGroupChunks($this->metadata());
+    }
+
+    public function rowsNumber(): int
+    {
+        return $this->metadata()->rowsNumber();
+    }
+
+    public function schema(): Schema
+    {
+        return $this->metadata()->schema();
+    }
+
+    public function totalByteSize(): int
+    {
+        $bytes = 0;
+
+        foreach ($this->metadata()->rowGroups()->all() as $rowGroup) {
+            $bytes += $rowGroup->totalByteSize();
+        }
+
+        return $bytes;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/All.php b/src/lib/parquet/src/Flow/Parquet/Filter/All.php
new file mode 100644
index 0000000000..1d246286b5
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/All.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+use function array_values;
+
+final readonly class All implements Filter
+{
+    /**
+     * @var list<Filter>
+     */
+    public array $filters;
+
+    public function __construct(Filter ...$filters)
+    {
+        $this->filters = array_values($filters);
+    }
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->all($this);
+    }
+
+    public function and(Filter $other): self
+    {
+        return new self($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return new Not($this);
+    }
+
+    public function or(Filter $other): Any
+    {
+        return new Any($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Any.php b/src/lib/parquet/src/Flow/Parquet/Filter/Any.php
new file mode 100644
index 0000000000..d015df3a05
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Any.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+use function array_values;
+
+final readonly class Any implements Filter
+{
+    /**
+     * @var list<Filter>
+     */
+    public array $filters;
+
+    public function __construct(Filter ...$filters)
+    {
+        $this->filters = array_values($filters);
+    }
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->any($this);
+    }
+
+    public function and(Filter $other): All
+    {
+        return new All($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return new Not($this);
+    }
+
+    public function or(Filter $other): self
+    {
+        return new self($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/AbsentLeaf.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/AbsentLeaf.php
new file mode 100644
index 0000000000..3c72a9db16
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/AbsentLeaf.php
@@ -0,0 +1,7 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+final readonly class AbsentLeaf {}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/BoundFilter.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/BoundFilter.php
new file mode 100644
index 0000000000..8fa34bd6c8
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/BoundFilter.php
@@ -0,0 +1,230 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\StartsWith;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use WeakMap;
+
+use function array_values;
+use function count;
+use function get_debug_type;
+
+final readonly class BoundFilter
+{
+    /**
+     * @var list<Filter> the root conjuncts rows are evaluated on: every leaf absent or answered exactly
+     */
+    private array $rowConjuncts;
+
+    /**
+     * @var list<Filter> the other root conjuncts
+     */
+    private array $residualConjuncts;
+
+    /**
+     * @param WeakMap<Comparison|In|IsNull|StartsWith, AbsentLeaf|RefusedLeaf|ResolvedLeaf> $leaves
+     */
+    private function __construct(
+        private Filter $filter,
+        private WeakMap $leaves,
+    ) {
+        $rowConjuncts = [];
+        $residualConjuncts = [];
+
+        foreach (self::conjuncts($filter) as $conjunct) {
+            if ($this->answersRows($conjunct)) {
+                $rowConjuncts[] = $conjunct;
+            } else {
+                $residualConjuncts[] = $conjunct;
+            }
+        }
+
+        $this->rowConjuncts = $rowConjuncts;
+        $this->residualConjuncts = $residualConjuncts;
+    }
+
+    /**
+     * Never throws for a reason that depends on the file: a leaf the file cannot answer is absent or refused.
+     */
+    public static function bind(Filter $filter, Schema $fileSchema, Options $options): self
+    {
+        $converters = DataConverter::initialize($options);
+        /** @var WeakMap<Comparison|In|IsNull|StartsWith, AbsentLeaf|RefusedLeaf|ResolvedLeaf> $leaves */
+        $leaves = new WeakMap();
+
+        foreach (self::leavesOf($filter) as $node) {
+            $leaves[$node] ??= LeafResolver::resolve($node, $fileSchema, $converters);
+        }
+
+        return new self($filter, $leaves);
+    }
+
+    /**
+     * The columns of the leaves answered exactly, each once.
+     *
+     * @return list<FlatColumn>
+     */
+    public function columns(): array
+    {
+        $columns = [];
+
+        foreach (self::leavesOf($this->filter) as $node) {
+            $resolution = $this->leaf($node);
+
+            if ($resolution instanceof ResolvedLeaf && $resolution->intervals !== null) {
+                $columns[$resolution->column->flatPath()] = $resolution->column;
+            }
+        }
+
+        return array_values($columns);
+    }
+
+    public function filter(): Filter
+    {
+        return $this->filter;
+    }
+
+    public function answersEveryConjunct(): bool
+    {
+        return $this->residualConjuncts === [];
+    }
+
+    public function leaf(Comparison|In|IsNull|StartsWith $node): AbsentLeaf|RefusedLeaf|ResolvedLeaf
+    {
+        return $this->leaves[$node] ?? throw new InvalidArgumentException('The leaf is not part of the bound filter');
+    }
+
+    /**
+     * The filter's leaves, depth first.
+     *
+     * @return list<Comparison|In|IsNull|StartsWith>
+     */
+    public function leaves(): array
+    {
+        return self::leavesOf($this->filter);
+    }
+
+    /**
+     * The root conjuncts rowFilter() leaves out, which the caller evaluates; null when there is none.
+     */
+    public function residual(): ?self
+    {
+        return $this->over($this->residualConjuncts);
+    }
+
+    /**
+     * The root conjuncts rows are evaluated on, with their leaves' resolutions; null when none is.
+     */
+    public function rowFilter(): ?self
+    {
+        return $this->residualConjuncts === [] && $this->rowConjuncts !== [] ? $this : $this->over($this->rowConjuncts);
+    }
+
+    public function rowLeaf(Comparison|In|IsNull|StartsWith $node): AbsentLeaf|ResolvedLeaf
+    {
+        $resolution = $this->leaf($node);
+
+        if (
+            $resolution instanceof AbsentLeaf
+            || $resolution instanceof ResolvedLeaf && $resolution->intervals !== null
+        ) {
+            return $resolution;
+        }
+
+        throw new InvalidArgumentException(
+            'Rows are evaluated on leaves answered exactly, the leaf on "' . $node->column->path . '" is not',
+        );
+    }
+
+    /**
+     * Nested All flattened: each is a conjunct of the root.
+     *
+     * @return list<Filter>
+     */
+    private static function conjuncts(Filter $filter): array
+    {
+        if (!$filter instanceof All) {
+            return [$filter];
+        }
+
+        $conjuncts = [];
+
+        foreach ($filter->filters as $child) {
+            foreach (self::conjuncts($child) as $conjunct) {
+                $conjuncts[] = $conjunct;
+            }
+        }
+
+        return $conjuncts;
+    }
+
+    /**
+     * @return list<Comparison|In|IsNull|StartsWith>
+     */
+    private static function leavesOf(Filter $filter): array
+    {
+        if ($filter instanceof All || $filter instanceof Any) {
+            $leaves = [];
+
+            foreach ($filter->filters as $child) {
+                foreach (self::leavesOf($child) as $node) {
+                    $leaves[] = $node;
+                }
+            }
+
+            return $leaves;
+        }
+
+        return match (true) {
+            $filter instanceof Not => self::leavesOf($filter->filter),
+            $filter instanceof Comparison,
+            $filter instanceof In,
+            $filter instanceof IsNull,
+            $filter instanceof StartsWith,
+                => [$filter],
+            default => throw new InvalidArgumentException('Unsupported filter ' . get_debug_type($filter)),
+        };
+    }
+
+    private function answersRows(Filter $conjunct): bool
+    {
+        foreach (self::leavesOf($conjunct) as $node) {
+            $resolution = $this->leaf($node);
+
+            if (
+                !$resolution instanceof AbsentLeaf
+                && (!$resolution instanceof ResolvedLeaf || $resolution->intervals === null)
+            ) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param list<Filter> $conjuncts
+     */
+    private function over(array $conjuncts): ?self
+    {
+        return match (count($conjuncts)) {
+            0 => null,
+            1 => new self($conjuncts[0], $this->leaves),
+            default => new self(new All(...$conjuncts), $this->leaves),
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/EqualRange.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/EqualRange.php
new file mode 100644
index 0000000000..ad15e7b4db
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/EqualRange.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use function bcadd;
+use function bccomp;
+use function bcdiv;
+use function bcmod;
+use function bcmul;
+use function bcsub;
+
+/**
+ * The lowest and highest physical value whose decoded value equals a literal, low above high when none does.
+ */
+final readonly class EqualRange
+{
+    public function __construct(
+        public bool|float|int|string|OutOfDomain $low,
+        public bool|float|int|string|OutOfDomain $high,
+    ) {}
+
+    /**
+     * Physical value p decodes to p * $step: the value is hit only on the grid.
+     *
+     * @param numeric-string $value
+     * @param numeric-string $step
+     */
+    public static function grid(string $value, string $step, int $min, int $max): self
+    {
+        $floor = bcdiv($value, $step, 0);
+
+        if (bccomp(bcmod($value, $step), '0') < 0) {
+            $floor = bcsub($floor, '1');
+        }
+
+        return self::integers(
+            bccomp(bcmul($floor, $step), $value) === 0 ? $floor : bcadd($floor, '1'),
+            $floor,
+            $min,
+            $max,
+        );
+    }
+
+    /**
+     * @param numeric-string $low
+     * @param numeric-string $high
+     */
+    public static function integers(string $low, string $high, int $min, int $max): self
+    {
+        return new self(self::edge($low, $min, $max), self::edge($high, $min, $max));
+    }
+
+    public static function point(bool|float|int|string|OutOfDomain $value): self
+    {
+        return new self($value, $value);
+    }
+
+    /**
+     * @param numeric-string $value
+     */
+    private static function edge(string $value, int $min, int $max): int|OutOfDomain
+    {
+        return match (true) {
+            bccomp($value, (string) $min) < 0 => OutOfDomain::Below,
+            bccomp($value, (string) $max) > 0 => OutOfDomain::Above,
+            default => (int) $value,
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/LeafResolver.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/LeafResolver.php
new file mode 100644
index 0000000000..4d503d094e
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/LeafResolver.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use DateTimeImmutable;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\PreImage\BytesPreImage;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\StartsWith;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function array_map;
+use function array_reverse;
+use function get_debug_type;
+use function sprintf;
+use function var_export;
+
+use const DATE_ATOM;
+
+/**
+ * A filter leaf against a file schema: pruning and evaluation read the same column, domain, literals and physical
+ * values.
+ */
+final readonly class LeafResolver
+{
+    public static function resolve(
+        Comparison|In|IsNull|StartsWith $leaf,
+        Schema $schema,
+        DataConverter $converters,
+    ): AbsentLeaf|RefusedLeaf|ResolvedLeaf {
+        $path = $leaf->column->path;
+
+        if (!$schema->has($path)) {
+            return new AbsentLeaf();
+        }
+
+        $column = $schema->get($path);
+
+        if (!$column instanceof FlatColumn) {
+            return new RefusedLeaf('Filter column "' . $path . '" is not a leaf column');
+        }
+
+        if ($column->maxRepetitionsLevel() > 0) {
+            return new RefusedLeaf(
+                'Filter column "' . $path . '" lies inside a list or a map, where a row holds no single value',
+            );
+        }
+
+        [$domain, $preImage] = LiteralDomain::forColumn($column, $converters->resolveConverter($column));
+        $literals = array_map($domain->normalise(...), match (true) {
+            $leaf instanceof Comparison => [$leaf->value],
+            $leaf instanceof In => $leaf->values,
+            default => [],
+        });
+
+        foreach ($literals as $literal) {
+            if (!$domain->holds($literal)) {
+                return new RefusedLeaf(sprintf(
+                    'Column "%s" (%s) cannot hold the %s literal %s',
+                    $path,
+                    $column->ddl()['type'],
+                    get_debug_type($literal),
+                    $literal instanceof DateTimeImmutable ? $literal->format(DATE_ATOM) : var_export($literal, true),
+                ));
+            }
+        }
+
+        if ($leaf instanceof StartsWith && !$domain->holdsPrefix()) {
+            return new RefusedLeaf(sprintf(
+                'Column "%s" (%s) holds no strings for a prefix',
+                $path,
+                $column->ddl()['type'],
+            ));
+        }
+
+        $fields = [];
+        $root = $column;
+
+        while (($parent = $root->parent()) !== null && !$parent->schemaRoot) {
+            $fields[] = $root->name();
+            $root = $parent;
+        }
+
+        $order = PhysicalOrder::forColumn($column);
+
+        return new ResolvedLeaf($column, $domain, $root->name(), array_reverse($fields), $literals, match (true) {
+            $leaf instanceof IsNull => new PhysicalIntervals($order, []),
+            $preImage === null => null,
+            $leaf instanceof Comparison => PhysicalIntervals::preImage(
+                $preImage,
+                $order,
+                $leaf->operator,
+                $literals[0],
+            ),
+            $leaf instanceof In => PhysicalIntervals::preImageOfSet($preImage, $order, $literals),
+            $leaf instanceof StartsWith => $preImage instanceof BytesPreImage
+                ? $preImage->startsWith($leaf->prefix)
+                : null,
+        });
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/LiteralDomain.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/LiteralDomain.php
new file mode 100644
index 0000000000..536b08cf5b
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/LiteralDomain.php
@@ -0,0 +1,160 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\PreImage\BooleanPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\BytesPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\DatePreImage;
+use Flow\Parquet\Filter\Binding\PreImage\DecimalPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\DoublePreImage;
+use Flow\Parquet\Filter\Binding\PreImage\Float32PreImage;
+use Flow\Parquet\Filter\Binding\PreImage\IntegerPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\TimestampPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\UnsignedInt64PreImage;
+use Flow\Parquet\Filter\Binding\PreImage\UuidPreImage;
+use Flow\Parquet\ParquetFile\Data\Converter;
+use Flow\Parquet\ParquetFile\Data\Converter\DecimalConverter;
+use Flow\Parquet\ParquetFile\Data\Converter\Int32DateConverter;
+use Flow\Parquet\ParquetFile\Data\Converter\Int64DateTimeConverter;
+use Flow\Parquet\ParquetFile\Data\Converter\Int96DateTimeConverter;
+use Flow\Parquet\ParquetFile\Data\Converter\JsonConverter;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt32Converter;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt64Converter;
+use Flow\Parquet\ParquetFile\Data\Converter\UuidConverter;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+use function abs;
+use function floor;
+use function is_bool;
+use function is_float;
+use function is_int;
+use function is_nan;
+use function is_string;
+use function pack;
+use function preg_match;
+use function strtolower;
+
+/**
+ * The literals a column's decoded values compare with; binding and evaluation both ask it.
+ */
+enum LiteralDomain
+{
+    case Boolean;
+    case Bytes;
+    case DateTime;
+    case None;
+    case Number;
+    case UnsignedInteger64;
+    case Uuid;
+
+    /**
+     * The largest magnitude up to which every integer is a double.
+     */
+    public const int EXACT_FLOAT_INTEGER = 2 ** 53;
+
+    /**
+     * The domain of the column's decoded values and their pre-image: null when no literal compares with them exactly.
+     *
+     * @return array{self, ?PreImage}
+     */
+    public static function forColumn(FlatColumn $column, ?Converter $converter): array
+    {
+        $logical = $column->logicalType();
+
+        return match (true) {
+            $converter instanceof Int32DateConverter => [self::DateTime, new DatePreImage()],
+            $converter instanceof Int64DateTimeConverter => [self::DateTime, TimestampPreImage::forColumn($column)],
+            $converter instanceof Int96DateTimeConverter => [self::DateTime, null],
+            $converter instanceof DecimalConverter => [self::Number, DecimalPreImage::forColumn($column)],
+            $converter instanceof UnsignedInt32Converter => [self::Number, new IntegerPreImage(0, 2 ** 32 - 1)],
+            $converter instanceof UnsignedInt64Converter => [
+                self::UnsignedInteger64,
+                new UnsignedInt64PreImage($converter),
+            ],
+            $converter instanceof UuidConverter => [self::Uuid, new UuidPreImage($converter)],
+            $converter instanceof JsonConverter => [self::Bytes, null],
+            $converter !== null => [self::None, null],
+            default => match ($column->type()) {
+                PhysicalType::BOOLEAN => [self::Boolean, new BooleanPreImage()],
+                PhysicalType::INT32, PhysicalType::INT64 => [self::Number, IntegerPreImage::forColumn($column)],
+                PhysicalType::FLOAT => [self::Number, new Float32PreImage()],
+                PhysicalType::DOUBLE => [self::Number, new DoublePreImage()],
+                PhysicalType::BYTE_ARRAY, PhysicalType::FIXED_LEN_BYTE_ARRAY => PhysicalOrder::forColumn($column)
+                    === PhysicalOrder::Bytes
+                        ? [
+                            self::Bytes,
+                            $logical === null || $logical->is(LogicalType::STRING) || $logical->is(LogicalType::ENUM)
+                                ? new BytesPreImage()
+                                : null,
+                        ]
+                        : [self::None, null],
+                PhysicalType::INT96 => [self::None, null],
+            },
+        };
+    }
+
+    public function holds(bool|DateTimeImmutable|float|int|string $literal): bool
+    {
+        return match ($this) {
+            self::Boolean => is_bool($literal),
+            self::Bytes => is_string($literal),
+            self::DateTime => $literal instanceof DateTimeImmutable,
+            self::None => false,
+            self::Number => is_int($literal) || is_float($literal),
+            self::UnsignedInteger64 => is_int($literal)
+                || is_float($literal)
+                || is_string($literal) && preg_match('/^(0|[1-9][0-9]*)$/', $literal) === 1,
+            self::Uuid => is_string($literal)
+                && preg_match('/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/', $literal) === 1,
+        };
+    }
+
+    /**
+     * Values equal in the domain's order share a key (int 1 and float 1.0 alike), so IN looks a value up instead of
+     * ordering it against each literal. Null orders it instead: NaN, a number beyond ±2^53 (where int and float
+     * equality stops being transitive), a boolean, a float against UINT_64.
+     */
+    public function key(mixed $value): int|string|null
+    {
+        return match ($this) {
+            self::Bytes, self::Uuid => is_string($value) ? $value : null,
+            self::DateTime => $value instanceof DateTimeInterface ? $value->format('U.u') : null,
+            self::Number => is_int($value) || is_float($value) ? self::numberKey($value) : null,
+            self::UnsignedInteger64 => is_int($value) || is_string($value) ? (string) $value : null,
+            self::Boolean, self::None => null,
+        };
+    }
+
+    /**
+     * The literal as the domain's values spell it: a uuid in lowercase, the form it decodes to.
+     */
+    public function normalise(bool|DateTimeImmutable|float|int|string $literal): bool|DateTimeImmutable|float|int|string
+    {
+        return $this === self::Uuid && is_string($literal) ? strtolower($literal) : $literal;
+    }
+
+    /**
+     * Whether a StartsWith prefix compares with the decoded values.
+     */
+    public function holdsPrefix(): bool
+    {
+        return $this === self::Bytes || $this === self::Uuid;
+    }
+
+    private static function numberKey(float|int $value): int|string|null
+    {
+        return match (true) {
+            is_nan($value), abs($value) > self::EXACT_FLOAT_INTEGER => null,
+            is_int($value) => $value,
+            $value === floor($value) => (int) $value,
+            default => pack('e', $value),
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/OutOfDomain.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/OutOfDomain.php
new file mode 100644
index 0000000000..07b44008c3
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/OutOfDomain.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+/**
+ * An edge below or above every physical value of the column.
+ */
+enum OutOfDomain
+{
+    case Above;
+    case Below;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PhysicalInterval.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PhysicalInterval.php
new file mode 100644
index 0000000000..773a655dd4
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PhysicalInterval.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+/**
+ * A null bound is unbounded.
+ */
+final readonly class PhysicalInterval
+{
+    public function __construct(
+        public bool|float|int|string|null $lower,
+        public bool $lowerInclusive,
+        public bool|float|int|string|null $upper,
+        public bool $upperInclusive,
+    ) {}
+
+    public static function unbounded(): self
+    {
+        return new self(null, false, null, false);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PhysicalIntervals.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PhysicalIntervals.php
new file mode 100644
index 0000000000..9bb2460e14
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PhysicalIntervals.php
@@ -0,0 +1,288 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use DateTimeImmutable;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Operator;
+
+use function array_key_exists;
+use function array_key_last;
+use function count;
+use function is_float;
+use function is_nan;
+use function usort;
+
+/**
+ * The physical values whose decoded value satisfies a leaf, as a union of intervals. Floats compare as IEEE 754 does
+ * outside NaN: -0.0 equals +0.0.
+ */
+final readonly class PhysicalIntervals
+{
+    /**
+     * @var list<array{null|int|string, null|int|string}> each interval's lower and upper bound key
+     */
+    private array $keys;
+
+    /**
+     * @var null|array<int|string, true> the key of each interval's only value, when every interval holds one
+     */
+    private ?array $points;
+
+    /**
+     * @param list<PhysicalInterval> $intervals sorted by lower bound, disjoint
+     */
+    public function __construct(
+        public PhysicalOrder $order,
+        public array $intervals,
+    ) {
+        $keys = [];
+        $points = [];
+
+        foreach ($intervals as $interval) {
+            $lower = $interval->lower === null ? null : self::key($order, $interval->lower);
+            $upper = $interval->upper === null ? null : self::key($order, $interval->upper);
+            $keys[] = [$lower, $upper];
+
+            if (
+                $points !== null
+                && $lower !== null
+                && $lower === $upper
+                && $interval->lowerInclusive
+                && $interval->upperInclusive
+            ) {
+                $points[$lower] = true;
+            } else {
+                $points = null;
+            }
+        }
+
+        $this->keys = $keys;
+        $this->points = $points;
+    }
+
+    /**
+     * Null when the column's decoded values cannot be compared with the literal exactly.
+     */
+    public static function preImage(
+        PreImage $preImage,
+        PhysicalOrder $order,
+        Operator $operator,
+        bool|DateTimeImmutable|float|int|string $literal,
+    ): ?self {
+        $equal = $preImage->equal($literal);
+
+        if ($equal === null) {
+            return null;
+        }
+
+        $interval = match ($operator) {
+            Operator::Equal => self::interval($order, $equal->low, true, $equal->high, true),
+            Operator::LessThan => self::interval($order, OutOfDomain::Below, false, $equal->low, false),
+            Operator::LessThanOrEqual => self::interval($order, OutOfDomain::Below, false, $equal->high, true),
+            Operator::GreaterThan => self::interval($order, $equal->high, false, OutOfDomain::Above, false),
+            Operator::GreaterThanOrEqual => self::interval($order, $equal->low, true, OutOfDomain::Above, false),
+        };
+
+        return new self($order, $interval === null ? [] : [$interval]);
+    }
+
+    /**
+     * Sorted by lower bound, each once: the pre-images of distinct values are disjoint, of equal values the same.
+     *
+     * @param list<bool|DateTimeImmutable|float|int|string> $literals
+     */
+    public static function preImageOfSet(PreImage $preImage, PhysicalOrder $order, array $literals): ?self
+    {
+        $intervals = [];
+
+        foreach ($literals as $literal) {
+            $equal = self::preImage($preImage, $order, Operator::Equal, $literal);
+
+            if ($equal === null) {
+                return null;
+            }
+
+            foreach ($equal->intervals as $interval) {
+                $intervals[] = $interval;
+            }
+        }
+
+        usort($intervals, static fn(PhysicalInterval $a, PhysicalInterval $b): int => self::compareLower(
+            $order,
+            $a,
+            $b,
+        ));
+
+        $distinct = [];
+
+        foreach ($intervals as $interval) {
+            $last = array_key_last($distinct);
+
+            if ($last === null || self::compareLower($order, $distinct[$last], $interval) !== 0) {
+                $distinct[] = $interval;
+            }
+        }
+
+        return new self($order, $distinct);
+    }
+
+    /**
+     * NaN lies in no interval.
+     */
+    public function contains(bool|float|int|string $value): bool
+    {
+        if (is_float($value) && is_nan($value)) {
+            return false;
+        }
+
+        $key = self::key($this->order, $value);
+
+        if ($this->points !== null) {
+            return array_key_exists($key, $this->points);
+        }
+
+        return $this->covering($key, $key);
+    }
+
+    /**
+     * [$min, $max] lies inside one interval.
+     */
+    public function covers(bool|float|int|string $min, bool|float|int|string $max): bool
+    {
+        return $this->covering(self::key($this->order, $min), self::key($this->order, $max));
+    }
+
+    /**
+     * No interval meets [$min, $max]: the intervals are disjoint and sorted, so only those starting at or below $max
+     * can, the last of them first.
+     */
+    public function disjoint(bool|float|int|string $min, bool|float|int|string $max): bool
+    {
+        $minKey = self::key($this->order, $min);
+        $maxKey = self::key($this->order, $max);
+
+        for ($index = $this->startingAtOrBelow($maxKey) - 1; $index >= 0; $index--) {
+            [$lower, $upper] = $this->keys[$index];
+            $interval = $this->intervals[$index];
+            $upperToMin = $upper === null ? 1 : $this->order->compareKeys($upper, $minKey);
+            $lowerToMax = $lower === null ? -1 : $this->order->compareKeys($lower, $maxKey);
+
+            if ($upperToMin < 0 || $upperToMin === 0 && !$interval->upperInclusive) {
+                return true;
+            }
+
+            if ($lowerToMax < 0 || $lowerToMax === 0 && $interval->lowerInclusive) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function isEmpty(): bool
+    {
+        return $this->intervals === [];
+    }
+
+    /**
+     * Null when the interval holds no physical value.
+     */
+    private static function interval(
+        PhysicalOrder $order,
+        bool|float|int|string|OutOfDomain $lower,
+        bool $lowerInclusive,
+        bool|float|int|string|OutOfDomain $upper,
+        bool $upperInclusive,
+    ): ?PhysicalInterval {
+        if ($lower === OutOfDomain::Above || $upper === OutOfDomain::Below) {
+            return null;
+        }
+
+        $lower = $lower === OutOfDomain::Below ? null : $lower;
+        $upper = $upper === OutOfDomain::Above ? null : $upper;
+
+        if ($lower !== null && $upper !== null) {
+            $comparison = $order->compareKeys(self::key($order, $lower), self::key($order, $upper));
+
+            if ($comparison > 0 || $comparison === 0 && (!$lowerInclusive || !$upperInclusive)) {
+                return null;
+            }
+        }
+
+        return new PhysicalInterval($lower, $lowerInclusive, $upper, $upperInclusive);
+    }
+
+    private static function compareLower(PhysicalOrder $order, PhysicalInterval $a, PhysicalInterval $b): int
+    {
+        return $a->lower === null || $b->lower === null
+            ? ($b->lower === null) <=> ($a->lower === null)
+            : $order->compareKeys(self::key($order, $a->lower), self::key($order, $b->lower));
+    }
+
+    /**
+     * -0.0 keyed as +0.0, so the physical order's keys compare floats as IEEE 754 does outside NaN.
+     */
+    private static function key(PhysicalOrder $order, bool|float|int|string $value): int|string
+    {
+        return $order->key(is_float($value) && $value === 0.0 ? 0.0 : $value);
+    }
+
+    /**
+     * Only the last interval starting at or below $minKey can hold it, or the one before when that one starts at
+     * $minKey exclusively.
+     */
+    private function covering(int|string $minKey, int|string $maxKey): bool
+    {
+        for ($index = $this->startingAtOrBelow($minKey) - 1; $index >= 0; $index--) {
+            if ($this->inside($index, $minKey, $maxKey)) {
+                return true;
+            }
+
+            $lower = $this->keys[$index][0];
+
+            if ($lower === null || $this->order->compareKeys($lower, $minKey) < 0) {
+                return false;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * How many intervals start at or below $key.
+     */
+    private function startingAtOrBelow(int|string $key): int
+    {
+        $low = 0;
+        $high = count($this->keys);
+
+        while ($low < $high) {
+            $middle = ($low + $high) >> 1;
+            $lower = $this->keys[$middle][0];
+
+            if ($lower === null || $this->order->compareKeys($lower, $key) <= 0) {
+                $low = $middle + 1;
+            } else {
+                $high = $middle;
+            }
+        }
+
+        return $low;
+    }
+
+    private function inside(int $index, int|string $minKey, int|string $maxKey): bool
+    {
+        [$lower, $upper] = $this->keys[$index];
+        $interval = $this->intervals[$index];
+        $lowerToMin = $lower === null ? -1 : $this->order->compareKeys($lower, $minKey);
+        $maxToUpper = $upper === null ? -1 : $this->order->compareKeys($maxKey, $upper);
+
+        return (
+            ($lowerToMin < 0 || $lowerToMin === 0 && $interval->lowerInclusive)
+            && ($maxToUpper < 0 || $maxToUpper === 0 && $interval->upperInclusive)
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage.php
new file mode 100644
index 0000000000..32e659eb75
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use DateTimeImmutable;
+
+interface PreImage
+{
+    /**
+     * Null when the column's decoded values cannot be compared with the literal exactly.
+     */
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/BooleanPreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/BooleanPreImage.php
new file mode 100644
index 0000000000..3f8991d7c2
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/BooleanPreImage.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PreImage;
+
+final readonly class BooleanPreImage implements PreImage
+{
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        /** @var bool $literal LiteralDomain::Boolean holds only booleans */
+        return EqualRange::point($literal);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/BytesPreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/BytesPreImage.php
new file mode 100644
index 0000000000..a50a0bb7a6
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/BytesPreImage.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PhysicalInterval;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Binding\PreImage;
+
+use function chr;
+use function ord;
+use function rtrim;
+use function strlen;
+use function substr;
+
+final readonly class BytesPreImage implements PreImage
+{
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        /** @var string $literal LiteralDomain::Bytes holds only strings */
+        return EqualRange::point($literal);
+    }
+
+    /**
+     * The values from the prefix up to its increment: a prefix of only 0xFF bytes has no upper bound.
+     */
+    public function startsWith(string $prefix): PhysicalIntervals
+    {
+        if ($prefix === '') {
+            return new PhysicalIntervals(PhysicalOrder::Bytes, [PhysicalInterval::unbounded()]);
+        }
+
+        $upper = rtrim($prefix, "\xFF");
+
+        return new PhysicalIntervals(PhysicalOrder::Bytes, [
+            $upper === ''
+                ? new PhysicalInterval($prefix, true, null, false)
+                : new PhysicalInterval(
+                    $prefix,
+                    true,
+                    substr($upper, 0, -1) . chr(ord($upper[strlen($upper) - 1]) + 1),
+                    false,
+                ),
+        ]);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DatePreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DatePreImage.php
new file mode 100644
index 0000000000..2d99ebea11
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DatePreImage.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PreImage;
+
+/**
+ * A day decodes to its UTC midnight: an instant off midnight equals no day.
+ */
+final readonly class DatePreImage implements PreImage
+{
+    private const string MICROS_PER_DAY = '86400000000';
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        /** @var DateTimeImmutable $literal LiteralDomain::DateTime holds only date times */
+        return EqualRange::grid(TimestampPreImage::micros($literal), self::MICROS_PER_DAY, -2 ** 31, 2 ** 31 - 1);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DecimalPreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DecimalPreImage.php
new file mode 100644
index 0000000000..c2ae64b2a7
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DecimalPreImage.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\OutOfDomain;
+use Flow\Parquet\Filter\Binding\PreImage;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+use function bcadd;
+use function bcpow;
+use function bcsub;
+use function Flow\Parquet\Binary\decimal_from_unscaled;
+use function Flow\Parquet\Binary\decimal_unscaled;
+use function is_float;
+use function is_infinite;
+use function is_int;
+use function pack;
+
+use const PHP_INT_MAX;
+
+/**
+ * A DECIMAL decodes to a float, exactly invertible up to precision 15 only. A byte decimal's edges are 8 big-endian
+ * bytes: the Decimal order sign-extends any width.
+ */
+final readonly class DecimalPreImage implements PreImage
+{
+    private const int MAX_EXACT_PRECISION = 15;
+
+    private function __construct(
+        private int $max,
+        private int $scale,
+        private bool $bytes,
+    ) {}
+
+    public static function forColumn(FlatColumn $column): ?self
+    {
+        $decimal = $column->logicalType()?->decimalData();
+
+        if ($decimal === null || $decimal->precision() > self::MAX_EXACT_PRECISION) {
+            return null;
+        }
+
+        return new self(
+            (int) bcsub(bcpow('10', (string) $decimal->precision()), '1'),
+            $decimal->scale(),
+            $column->type() !== PhysicalType::INT32 && $column->type() !== PhysicalType::INT64,
+        );
+    }
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        $value = match (true) {
+            is_int($literal) => (float) $literal,
+            is_float($literal) && !is_infinite($literal) => $literal,
+            default => null,
+        };
+
+        if ($value === null) {
+            return null;
+        }
+
+        $unscaled = decimal_unscaled($value, PHP_INT_MAX, $this->scale);
+        $decoded = decimal_from_unscaled($unscaled, $this->scale);
+        $floor = $decoded <= $value ? $unscaled : bcsub($unscaled, '1');
+        $range = EqualRange::integers(
+            $decoded === $value ? $floor : bcadd($floor, '1'),
+            $floor,
+            -$this->max,
+            $this->max,
+        );
+
+        return $this->bytes ? new EqualRange(self::bytes($range->low), self::bytes($range->high)) : $range;
+    }
+
+    private static function bytes(bool|float|int|string|OutOfDomain $edge): bool|float|int|string|OutOfDomain
+    {
+        return is_int($edge) ? pack('J', $edge) : $edge;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DoublePreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DoublePreImage.php
new file mode 100644
index 0000000000..d287c7ac2a
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/DoublePreImage.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\PreImage;
+
+use function abs;
+use function is_float;
+use function is_int;
+
+final readonly class DoublePreImage implements PreImage
+{
+    /**
+     * The literal as the double it compares with, -0.0 as +0.0; null for a kind that is no number or an int a double
+     * cannot hold exactly.
+     */
+    public static function value(bool|DateTimeImmutable|float|int|string $literal): ?float
+    {
+        return match (true) {
+            is_int($literal) => abs($literal) <= LiteralDomain::EXACT_FLOAT_INTEGER ? (float) $literal : null,
+            is_float($literal) => $literal === 0.0 ? 0.0 : $literal,
+            default => null,
+        };
+    }
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        $value = self::value($literal);
+
+        return $value === null ? null : EqualRange::point($value);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/Float32PreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/Float32PreImage.php
new file mode 100644
index 0000000000..19caacf4d3
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/Float32PreImage.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PreImage;
+
+use function pack;
+use function unpack;
+
+/**
+ * A FLOAT decodes to the exact double of its 32 bits: a literal between two of them equals neither, and one beyond the
+ * largest float32 lies between it and the infinity.
+ */
+final readonly class Float32PreImage implements PreImage
+{
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        $value = DoublePreImage::value($literal);
+
+        if ($value === null) {
+            return null;
+        }
+
+        /** @var array{1: float} $unpacked */
+        $unpacked = unpack('g', pack('g', $value));
+        $rounded = $unpacked[1];
+
+        if ($rounded === $value) {
+            return EqualRange::point($value);
+        }
+
+        $key = (int) PhysicalOrder::Float->key($rounded);
+
+        return $rounded > $value
+            ? new EqualRange($rounded, self::fromKey($key - 1))
+            : new EqualRange(self::fromKey($key + 1), $rounded);
+    }
+
+    private static function fromKey(int $key): float
+    {
+        /** @var array{1: float} $unpacked */
+        $unpacked = unpack('g', pack('V', ($key ^ (($key >> 31) & 0x7FFFFFFF)) & 0xFFFFFFFF));
+
+        return $unpacked[1];
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/IntegerPreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/IntegerPreImage.php
new file mode 100644
index 0000000000..399abde75f
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/IntegerPreImage.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\PreImage;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Integer;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+use function abs;
+use function ceil;
+use function floor;
+use function is_float;
+use function is_int;
+
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+/**
+ * A float literal compares exactly up to 2^53: a fraction lies between two integers and equals neither.
+ */
+final readonly class IntegerPreImage implements PreImage
+{
+    public function __construct(
+        private int $min,
+        private int $max,
+    ) {}
+
+    public static function forColumn(FlatColumn $column): self
+    {
+        $integer = Integer::forColumn($column);
+        $bits = $integer?->bitWidth() ?? ($column->type() === PhysicalType::INT32 ? 32 : 64);
+
+        return match (true) {
+            $bits === 64 => new self(PHP_INT_MIN, PHP_INT_MAX),
+            $integer?->isSigned() === false => new self(0, 2 ** $bits - 1),
+            default => new self(-2 ** ($bits - 1), 2 ** ($bits - 1) - 1),
+        };
+    }
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        if (is_int($literal)) {
+            return EqualRange::integers((string) $literal, (string) $literal, $this->min, $this->max);
+        }
+
+        if (!is_float($literal) || abs($literal) > LiteralDomain::EXACT_FLOAT_INTEGER) {
+            return null;
+        }
+
+        return EqualRange::integers(
+            (string) (int) ceil($literal),
+            (string) (int) floor($literal),
+            $this->min,
+            $this->max,
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/TimestampPreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/TimestampPreImage.php
new file mode 100644
index 0000000000..3ba3877cc4
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/TimestampPreImage.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PreImage;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+
+use function bcadd;
+use function bcmul;
+
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+/**
+ * Millis hit a micros literal only on the milli grid; nanos decode floored to micros.
+ */
+final readonly class TimestampPreImage implements PreImage
+{
+    public function __construct(
+        private TimeUnit $unit,
+    ) {}
+
+    public static function forColumn(FlatColumn $column): ?self
+    {
+        $unit = $column->logicalType()?->timestampData()?->unit();
+
+        return $unit === null ? null : new self($unit);
+    }
+
+    /**
+     * @return numeric-string
+     */
+    public static function micros(DateTimeImmutable $literal): string
+    {
+        /** @var numeric-string $fraction */
+        $fraction = $literal->format('u');
+
+        return bcadd(bcmul((string) $literal->getTimestamp(), '1000000'), $fraction);
+    }
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        /** @var DateTimeImmutable $literal LiteralDomain::DateTime holds only date times */
+        $micros = self::micros($literal);
+        $nanos = bcmul($micros, '1000');
+
+        return match ($this->unit) {
+            TimeUnit::MILLISECONDS => EqualRange::grid($micros, '1000', PHP_INT_MIN, PHP_INT_MAX),
+            TimeUnit::MICROSECONDS => EqualRange::integers($micros, $micros, PHP_INT_MIN, PHP_INT_MAX),
+            TimeUnit::NANOSECONDS => EqualRange::integers($nanos, bcadd($nanos, '999'), PHP_INT_MIN, PHP_INT_MAX),
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/UnsignedInt64PreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/UnsignedInt64PreImage.php
new file mode 100644
index 0000000000..3e56c81362
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/UnsignedInt64PreImage.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\OutOfDomain;
+use Flow\Parquet\Filter\Binding\PreImage;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt64Converter;
+
+use function abs;
+use function ceil;
+use function floor;
+use function is_float;
+use function is_int;
+
+/**
+ * UINT_64 decodes to a digit string; its physical value is the INT64 bit pattern, ordered unsigned. A float compares
+ * numerically, a fraction lying between two integers.
+ */
+final readonly class UnsignedInt64PreImage implements PreImage
+{
+    public function __construct(
+        private UnsignedInt64Converter $converter,
+    ) {}
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        if (is_float($literal)) {
+            return abs($literal) > LiteralDomain::EXACT_FLOAT_INTEGER
+                ? null
+                : new EqualRange($this->edge((int) ceil($literal)), $this->edge((int) floor($literal)));
+        }
+
+        // LiteralDomain::UnsignedInteger64 leaves an int or a canonical digit string: outside the type it lies below or above
+        return match (true) {
+            UnsignedInt64Converter::accepts($literal) => EqualRange::point($this->converter->toParquetType($literal)),
+            is_int($literal) => EqualRange::point(OutOfDomain::Below),
+            default => EqualRange::point(OutOfDomain::Above),
+        };
+    }
+
+    private function edge(int $value): int|OutOfDomain
+    {
+        return $value < 0 ? OutOfDomain::Below : $this->converter->toParquetType($value);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/UuidPreImage.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/UuidPreImage.php
new file mode 100644
index 0000000000..18a53e6c0c
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/PreImage/UuidPreImage.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PreImage;
+use Flow\Parquet\ParquetFile\Data\Converter\UuidConverter;
+
+/**
+ * Only the canonical lowercase form: the column decodes to it, so another spelling never equals a value.
+ */
+final readonly class UuidPreImage implements PreImage
+{
+    public function __construct(
+        private UuidConverter $converter,
+    ) {}
+
+    public function equal(bool|DateTimeImmutable|float|int|string $literal): ?EqualRange
+    {
+        /** @var string $literal LiteralDomain::Uuid holds only lowercase uuid strings */
+        return EqualRange::point($this->converter->toParquetType($literal));
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/RefusedLeaf.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/RefusedLeaf.php
new file mode 100644
index 0000000000..b315ae581e
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/RefusedLeaf.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+/**
+ * A leaf no row answers: pruning reads it as Maybe, evaluation refuses it with $reason.
+ */
+final readonly class RefusedLeaf
+{
+    public function __construct(
+        public string $reason,
+    ) {}
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Binding/ResolvedLeaf.php b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/ResolvedLeaf.php
new file mode 100644
index 0000000000..591464dba2
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Binding/ResolvedLeaf.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Binding;
+
+use DateTimeImmutable;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+final readonly class ResolvedLeaf
+{
+    /**
+     * @param list<string> $fields the struct fields from the root column down to the leaf
+     * @param list<bool|DateTimeImmutable|float|int|string> $literals the leaf's literals, normalised by the domain
+     * @param null|PhysicalIntervals $intervals the non-null physical values the leaf holds for (none for IsNull); null
+     *                                          when no physical value answers the leaf exactly
+     */
+    public function __construct(
+        public FlatColumn $column,
+        public LiteralDomain $domain,
+        public string $root,
+        public array $fields,
+        public array $literals,
+        public ?PhysicalIntervals $intervals,
+    ) {}
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/ColumnRef.php b/src/lib/parquet/src/Flow/Parquet/Filter/ColumnRef.php
new file mode 100644
index 0000000000..c402359356
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/ColumnRef.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+use InvalidArgumentException;
+
+final readonly class ColumnRef
+{
+    public function __construct(
+        public string $path,
+    ) {
+        if ($path === '') {
+            throw new InvalidArgumentException('A column path cannot be empty');
+        }
+    }
+
+    public function equals(mixed $value): Comparison
+    {
+        return new Comparison($this, Operator::Equal, $value);
+    }
+
+    public function greaterThan(mixed $value): Comparison
+    {
+        return new Comparison($this, Operator::GreaterThan, $value);
+    }
+
+    public function greaterThanOrEqual(mixed $value): Comparison
+    {
+        return new Comparison($this, Operator::GreaterThanOrEqual, $value);
+    }
+
+    /**
+     * @param array<mixed> $values
+     */
+    public function in(array $values): In
+    {
+        return new In($this, $values);
+    }
+
+    public function isNotNull(): Not
+    {
+        return new Not($this->isNull());
+    }
+
+    public function isNull(): IsNull
+    {
+        return new IsNull($this);
+    }
+
+    public function lessThan(mixed $value): Comparison
+    {
+        return new Comparison($this, Operator::LessThan, $value);
+    }
+
+    public function lessThanOrEqual(mixed $value): Comparison
+    {
+        return new Comparison($this, Operator::LessThanOrEqual, $value);
+    }
+
+    public function notEquals(mixed $value): Not
+    {
+        return new Not($this->equals($value));
+    }
+
+    /**
+     * @param array<mixed> $values
+     */
+    public function notIn(array $values): Not
+    {
+        return new Not($this->in($values));
+    }
+
+    public function startsWith(string $prefix): StartsWith
+    {
+        return new StartsWith($this, $prefix);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Comparison.php b/src/lib/parquet/src/Flow/Parquet/Filter/Comparison.php
new file mode 100644
index 0000000000..e10a2d0966
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Comparison.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+use DateTimeImmutable;
+
+final readonly class Comparison implements Filter
+{
+    public bool|DateTimeImmutable|float|int|string $value;
+
+    public function __construct(
+        public ColumnRef $column,
+        public Operator $operator,
+        mixed $value,
+    ) {
+        $this->value = Literal::of($value);
+    }
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->comparison($this);
+    }
+
+    public function and(Filter $other): All
+    {
+        return new All($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return new Not($this);
+    }
+
+    public function or(Filter $other): Any
+    {
+        return new Any($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/BatchTruth.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/BatchTruth.php
new file mode 100644
index 0000000000..50cfdd555b
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/BatchTruth.php
@@ -0,0 +1,293 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\FilterVisitor;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\Filter\StartsWith;
+use WeakMap;
+
+use function array_fill;
+use function array_key_exists;
+use function bccomp;
+use function get_debug_type;
+use function is_array;
+use function is_bool;
+use function is_finite;
+use function is_float;
+use function is_int;
+use function is_nan;
+use function is_numeric;
+use function is_string;
+use function number_format;
+use function sprintf;
+use function str_starts_with;
+use function strcmp;
+
+/**
+ * One batch's truth per row for each node of a filter; a leaf without a resolution is an absent column, null.
+ *
+ * @implements FilterVisitor<list<null|bool>>
+ */
+final readonly class BatchTruth implements FilterVisitor
+{
+    /**
+     * @param WeakMap<Comparison|In|IsNull|StartsWith, ResolvedLeaf> $leaves
+     * @param WeakMap<In, array<int|string, true>> $keys
+     * @param array<string, list<mixed>> $batch
+     * @param non-negative-int $rows
+     */
+    public function __construct(
+        private WeakMap $leaves,
+        private WeakMap $keys,
+        private array $batch,
+        private int $rows,
+    ) {}
+
+    public function all(All $all): array
+    {
+        $result = array_fill(0, $this->rows, true);
+
+        foreach ($all->filters as $filter) {
+            foreach ($filter->accept($this) as $row => $truth) {
+                if ($truth === false) {
+                    $result[$row] = false;
+                } elseif ($truth === null && $result[$row] === true) {
+                    $result[$row] = null;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    public function any(Any $any): array
+    {
+        $result = array_fill(0, $this->rows, false);
+
+        foreach ($any->filters as $filter) {
+            foreach ($filter->accept($this) as $row => $truth) {
+                if ($truth === true) {
+                    $result[$row] = true;
+                } elseif ($truth === null && $result[$row] === false) {
+                    $result[$row] = null;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    public function comparison(Comparison $comparison): array
+    {
+        $leaf = $this->leaves[$comparison] ?? null;
+
+        if ($leaf === null) {
+            return array_fill(0, $this->rows, null);
+        }
+
+        $result = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($this->values($leaf) as $value) {
+            if ($value === null) {
+                $result[] = null;
+
+                continue;
+            }
+
+            if (is_float($value) && is_nan($value)) {
+                $result[] = false;
+
+                continue;
+            }
+
+            $order = $this->order($leaf->domain, $value, $leaf->literals[0]);
+            $result[] = match ($comparison->operator) {
+                Operator::Equal => $order === 0,
+                Operator::LessThan => $order < 0,
+                Operator::LessThanOrEqual => $order <= 0,
+                Operator::GreaterThan => $order > 0,
+                Operator::GreaterThanOrEqual => $order >= 0,
+            };
+        }
+
+        return $result;
+    }
+
+    public function in(In $in): array
+    {
+        $leaf = $this->leaves[$in] ?? null;
+
+        if ($leaf === null) {
+            return array_fill(0, $this->rows, null);
+        }
+
+        $keys = $this->keys[$in] ?? null;
+        $result = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($this->values($leaf) as $value) {
+            if ($value === null) {
+                $result[] = null;
+
+                continue;
+            }
+
+            $key = $keys === null ? null : $leaf->domain->key($value);
+
+            if ($keys !== null && $key !== null) {
+                $result[] = array_key_exists($key, $keys);
+
+                continue;
+            }
+
+            $match = false;
+
+            if (!is_float($value) || !is_nan($value)) {
+                foreach ($leaf->literals as $literal) {
+                    if ($this->order($leaf->domain, $value, $literal) === 0) {
+                        $match = true;
+
+                        break;
+                    }
+                }
+            }
+
+            $result[] = $match;
+        }
+
+        return $result;
+    }
+
+    public function isNull(IsNull $isNull): array
+    {
+        $leaf = $this->leaves[$isNull] ?? null;
+
+        if ($leaf === null) {
+            return array_fill(0, $this->rows, true);
+        }
+
+        $result = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($this->values($leaf) as $value) {
+            $result[] = $value === null;
+        }
+
+        return $result;
+    }
+
+    public function not(Not $not): array
+    {
+        $result = [];
+
+        foreach ($not->filter->accept($this) as $truth) {
+            $result[] = $truth === null ? null : !$truth;
+        }
+
+        return $result;
+    }
+
+    public function startsWith(StartsWith $startsWith): array
+    {
+        $leaf = $this->leaves[$startsWith] ?? null;
+
+        if ($leaf === null) {
+            return array_fill(0, $this->rows, null);
+        }
+
+        $result = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($this->values($leaf) as $value) {
+            $result[] = is_string($value) ? str_starts_with($value, $startsWith->prefix) : null;
+        }
+
+        return $result;
+    }
+
+    /**
+     * The literal passed the domain check, so a decoded value orders with it.
+     */
+    private function order(LiteralDomain $domain, mixed $value, bool|DateTimeImmutable|float|int|string $literal): int
+    {
+        if ($domain === LiteralDomain::UnsignedInteger64 && is_string($value) && is_numeric($value)) {
+            if (is_float($literal)) {
+                if (!is_finite($literal)) {
+                    return $literal > 0 ? -1 : 1;
+                }
+
+                /** @var numeric-string $decimal */
+                $decimal = number_format($literal, 20, '.', '');
+
+                return bccomp($value, $decimal, 20);
+            }
+
+            return match (true) {
+                is_int($literal) => bccomp($value, (string) $literal),
+                is_string($literal) && is_numeric($literal) => bccomp($value, $literal),
+                default => throw self::unordered($value, $literal),
+            };
+        }
+
+        return match (true) {
+            is_string($value) && is_string($literal) => strcmp($value, $literal) <=> 0,
+            (is_int($value) || is_float($value)) && (is_int($literal) || is_float($literal)) => $value <=> $literal,
+            is_bool($value) && is_bool($literal) => $value <=> $literal,
+            $value instanceof DateTimeInterface && $literal instanceof DateTimeInterface => $value <=> $literal,
+            default => throw self::unordered($value, $literal),
+        };
+    }
+
+    private static function unordered(mixed $value, bool|DateTimeImmutable|float|int|string $literal): RuntimeException
+    {
+        return new RuntimeException(sprintf(
+            'A decoded %s does not order with the %s literal',
+            get_debug_type($value),
+            get_debug_type($literal),
+        ));
+    }
+
+    /**
+     * @return list<mixed>
+     */
+    private function values(ResolvedLeaf $leaf): array
+    {
+        $column = $this->batch[$leaf->root] ?? throw new InvalidArgumentException(
+            'The batch holds no column "' . $leaf->root . '"',
+        );
+
+        if ($leaf->fields === []) {
+            return $column;
+        }
+
+        $values = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($column as $value) {
+            foreach ($leaf->fields as $field) {
+                // @mago-ignore analysis:mixed-assignment
+                $value = is_array($value) && array_key_exists($field, $value) ? $value[$field] : null;
+            }
+
+            $values[] = $value;
+        }
+
+        return $values;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/BloomEvaluator.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/BloomEvaluator.php
new file mode 100644
index 0000000000..22225ccc4d
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/BloomEvaluator.php
@@ -0,0 +1,148 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\FilterVisitor;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\Filter\StartsWith;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Generator;
+
+use function is_float;
+
+/**
+ * A bloom filter proves only absence: a positive Equal or In leaf whose literals are all absent is Never, every other
+ * leaf is Maybe. A row group's filter is read only for such a leaf.
+ *
+ * @implements FilterVisitor<Truth>
+ */
+final readonly class BloomEvaluator implements FilterVisitor
+{
+    private function __construct(
+        private BoundFilter $filter,
+        private Indexes $indexes,
+        private int $rowGroup,
+    ) {}
+
+    public static function evaluate(BoundFilter $filter, Indexes $indexes, int $rowGroup): Truth
+    {
+        return $filter->filter()->accept(new self($filter, $indexes, $rowGroup));
+    }
+
+    public function comparison(Comparison $comparison): Truth
+    {
+        return $comparison->operator === Operator::Equal ? $this->membership($comparison) : Truth::Maybe;
+    }
+
+    public function all(All $all): Truth
+    {
+        return Truth::every($this->truths($all->filters));
+    }
+
+    public function any(Any $any): Truth
+    {
+        return Truth::some($this->truths($any->filters));
+    }
+
+    public function in(In $in): Truth
+    {
+        return $this->membership($in);
+    }
+
+    public function isNull(IsNull $isNull): Truth
+    {
+        return Truth::Maybe;
+    }
+
+    /**
+     * Under a negation every leaf is Maybe: a bloom filter proves only absence.
+     */
+    public function not(Not $not): Truth
+    {
+        return Truth::Maybe;
+    }
+
+    public function startsWith(StartsWith $startsWith): Truth
+    {
+        return Truth::Maybe;
+    }
+
+    /**
+     * Never when no point of the leaf's pre-image is in the filter. A zero is checked as both -0.0 and +0.0, which
+     * compare equal but hash apart.
+     */
+    private function membership(Comparison|In $node): Truth
+    {
+        $resolution = $this->filter->leaf($node);
+
+        if (!$resolution instanceof ResolvedLeaf || $resolution->intervals === null) {
+            return Truth::Maybe;
+        }
+
+        $points = [];
+
+        foreach ($resolution->intervals->intervals as $interval) {
+            if (
+                $interval->lower === null
+                || $interval->lower !== $interval->upper
+                || !$interval->lowerInclusive
+                || !$interval->upperInclusive
+            ) {
+                return Truth::Maybe;
+            }
+
+            $points[] = $interval->lower;
+
+            if (is_float($interval->lower) && $interval->lower === 0.0) {
+                $points[] = -$interval->lower;
+            }
+        }
+
+        if ($points === []) {
+            return Truth::Never;
+        }
+
+        $bloomFilter = $this->indexes->bloomFilter($this->rowGroup, $resolution->column);
+
+        if ($bloomFilter === null) {
+            return Truth::Maybe;
+        }
+
+        $hash = new BloomHash();
+
+        foreach ($points as $point) {
+            if ($bloomFilter->check($hash->of($resolution->column, $point))) {
+                return Truth::Maybe;
+            }
+        }
+
+        return Truth::Never;
+    }
+
+    /**
+     * Each filter's truth, evaluated only when the combinator asks for it.
+     *
+     * @param list<Filter> $filters
+     *
+     * @return Generator<Truth>
+     */
+    private function truths(array $filters): Generator
+    {
+        foreach ($filters as $filter) {
+            yield $filter->accept($this);
+        }
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/FilterEvaluator.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/FilterEvaluator.php
new file mode 100644
index 0000000000..47312266cf
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/FilterEvaluator.php
@@ -0,0 +1,121 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Binding\RefusedLeaf;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\StartsWith;
+use WeakMap;
+
+use function array_values;
+use function count;
+use function reset;
+
+/**
+ * Column-wise, so a batch is filtered without building rows.
+ */
+final readonly class FilterEvaluator
+{
+    /**
+     * @var WeakMap<In, array<int|string, true>>
+     */
+    private WeakMap $keys;
+
+    /**
+     * @var WeakMap<Comparison|In|IsNull|StartsWith, ResolvedLeaf>
+     */
+    private WeakMap $leaves;
+
+    /**
+     * Refuses at once what no row could answer, instead of matching nothing silently.
+     */
+    public function __construct(
+        private BoundFilter $filter,
+    ) {
+        /** @var WeakMap<Comparison|In|IsNull|StartsWith, ResolvedLeaf> $leaves */
+        $leaves = new WeakMap();
+        /** @var WeakMap<In, array<int|string, true>> $keys */
+        $keys = new WeakMap();
+
+        foreach ($filter->leaves() as $node) {
+            $resolution = $filter->leaf($node);
+
+            if ($resolution instanceof RefusedLeaf) {
+                throw new InvalidArgumentException($resolution->reason);
+            }
+
+            if (!$resolution instanceof ResolvedLeaf) {
+                continue;
+            }
+
+            $leaves[$node] = $resolution;
+
+            if ($node instanceof In) {
+                $literalKeys = [];
+
+                foreach ($resolution->literals as $literal) {
+                    $key = $resolution->domain->key($literal);
+
+                    if ($key === null) {
+                        continue 2;
+                    }
+
+                    $literalKeys[$key] = true;
+                }
+
+                $keys[$node] = $literalKeys;
+            }
+        }
+
+        $this->leaves = $leaves;
+        $this->keys = $keys;
+    }
+
+    /**
+     * The indexes of the rows the filter is true for.
+     *
+     * @param array<string, list<mixed>> $batch decoded values by root column, every list the same length
+     *
+     * @return list<int>
+     */
+    public function mask(array $batch): array
+    {
+        $first = reset($batch);
+        $matching = [];
+
+        foreach ($this->filter
+            ->filter()
+            ->accept(
+                new BatchTruth($this->leaves, $this->keys, $batch, $first === false ? 0 : count($first)),
+            ) as $row => $truth) {
+            if ($truth === true) {
+                $matching[] = $row;
+            }
+        }
+
+        return $matching;
+    }
+
+    /**
+     * The root columns a batch must hold.
+     *
+     * @return list<string>
+     */
+    public function roots(): array
+    {
+        $roots = [];
+
+        foreach ($this->leaves as $resolution) {
+            $roots[$resolution->root] = $resolution->root;
+        }
+
+        return array_values($roots);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/PageZoneMaps.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/PageZoneMaps.php
new file mode 100644
index 0000000000..9148346da6
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/PageZoneMaps.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\Data\PhysicalCodec;
+use Flow\Parquet\ParquetFile\PageIndex\PageIndex;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function array_key_exists;
+
+/**
+ * One row group's page statistics, each page decoded once. at() views the pages holding one row, so columns whose pages
+ * break at other rows are evaluated together over the rows their pages share.
+ */
+final class PageZoneMaps
+{
+    /**
+     * @var array<string, array<int, ZoneMap>> by flat path, then page
+     */
+    private array $zones = [];
+
+    /**
+     * @param array<string, PageIndex> $pageIndexes by flat path, a column without one has no zone
+     */
+    public function __construct(
+        private readonly RowGroupChunks $chunks,
+        private readonly array $pageIndexes,
+    ) {}
+
+    public function at(int $row): ZoneMaps
+    {
+        return new PageZoneMapsAtRow($this, $row);
+    }
+
+    public function zone(FlatColumn $column, int $row): ?ZoneMap
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($path, $this->pageIndexes)) {
+            return null;
+        }
+
+        $pageIndex = $this->pageIndexes[$path];
+        $page = $pageIndex->pageOf($row);
+
+        return $this->zones[$path][$page] ??= $this->decode($column, $pageIndex, $page);
+    }
+
+    /**
+     * Column index bounds carry no exactness flag.
+     */
+    private function decode(FlatColumn $column, PageIndex $pageIndex, int $page): ZoneMap
+    {
+        $columnIndex = $pageIndex->columnIndex;
+        $rows = $pageIndex->pageRows($page);
+        $nanCount = $columnIndex->nanCounts[$page] ?? null;
+
+        if ($columnIndex->nullPages[$page]) {
+            return new ZoneMap(null, null, true, true, $rows, $nanCount, $rows, false);
+        }
+
+        $codec = new PhysicalCodec();
+
+        return ZoneMap::fromStatistics(
+            column: $column,
+            columnOrder: $this->chunks->columnOrder($column),
+            min: $codec->decodeStatistic($column, $columnIndex->minValues[$page]),
+            max: $codec->decodeStatistic($column, $columnIndex->maxValues[$page]),
+            minExact: null,
+            maxExact: null,
+            nullCount: $columnIndex->nullCounts[$page] ?? null,
+            nanCount: $nanCount,
+            rowCount: $rows,
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/PageZoneMapsAtRow.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/PageZoneMapsAtRow.php
new file mode 100644
index 0000000000..a7ea0b49d4
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/PageZoneMapsAtRow.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+final readonly class PageZoneMapsAtRow implements ZoneMaps
+{
+    public function __construct(
+        private PageZoneMaps $pages,
+        private int $row,
+    ) {}
+
+    public function zone(FlatColumn $column): ?ZoneMap
+    {
+        return $this->pages->zone($column, $this->row);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/RowEvaluator.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/RowEvaluator.php
new file mode 100644
index 0000000000..fde24edd19
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/RowEvaluator.php
@@ -0,0 +1,192 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Binding\AbsentLeaf;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\FilterVisitor;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\StartsWith;
+
+use function array_fill;
+use function array_key_exists;
+use function count;
+use function is_string;
+use function sprintf;
+use function str_starts_with;
+
+/**
+ * The rows a filter is TRUE for, on undecoded physical values: floats compare as IEEE 754 (NaN is false, -0.0 equals
+ * +0.0), every other type in its physical order. Not is pushed down to the leaves as a polarity, so a NULL is TRUE in
+ * neither.
+ *
+ * @implements FilterVisitor<list<bool>>
+ */
+final readonly class RowEvaluator implements FilterVisitor
+{
+    /**
+     * @param array<string, list<mixed>> $physicalByPath one physical value or null per row, keyed by FlatColumn::flatPath()
+     * @param non-negative-int $rows
+     */
+    private function __construct(
+        private BoundFilter $filter,
+        private array $physicalByPath,
+        private int $rows,
+        private bool $negated = false,
+    ) {}
+
+    /**
+     * @param array<string, list<mixed>> $physicalByPath one physical value or null per row, keyed by FlatColumn::flatPath()
+     * @param non-negative-int $rows
+     *
+     * @return list<bool> true = keep
+     */
+    public static function evaluate(BoundFilter $filter, array $physicalByPath, int $rows): array
+    {
+        return $filter->filter()->accept(new self($filter, $physicalByPath, $rows));
+    }
+
+    public function all(All $all): array
+    {
+        return $this->combined($all->filters, !$this->negated);
+    }
+
+    public function any(Any $any): array
+    {
+        return $this->combined($any->filters, $this->negated);
+    }
+
+    public function comparison(Comparison $comparison): array
+    {
+        return $this->membership($comparison);
+    }
+
+    public function in(In $in): array
+    {
+        return $this->membership($in);
+    }
+
+    public function isNull(IsNull $isNull): array
+    {
+        $resolution = $this->filter->rowLeaf($isNull);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return array_fill(0, $this->rows, !$this->negated);
+        }
+
+        $result = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($this->values($resolution) as $value) {
+            $result[] = ($value === null) !== $this->negated;
+        }
+
+        return $result;
+    }
+
+    public function not(Not $not): array
+    {
+        return $not->filter->accept(new self($this->filter, $this->physicalByPath, $this->rows, !$this->negated));
+    }
+
+    public function startsWith(StartsWith $startsWith): array
+    {
+        $resolution = $this->filter->rowLeaf($startsWith);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return array_fill(0, $this->rows, false);
+        }
+
+        $result = [];
+
+        // @mago-ignore analysis:mixed-assignment
+        foreach ($this->values($resolution) as $value) {
+            $result[] = is_string($value) && str_starts_with($value, $startsWith->prefix) !== $this->negated;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Each row TRUE in every filter when $conjunction, in any otherwise.
+     *
+     * @param list<Filter> $filters
+     *
+     * @return list<bool>
+     */
+    private function combined(array $filters, bool $conjunction): array
+    {
+        $result = array_fill(0, $this->rows, $conjunction);
+
+        foreach ($filters as $filter) {
+            foreach ($filter->accept($this) as $row => $truth) {
+                if ($truth !== $conjunction) {
+                    $result[$row] = $truth;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * A non-null value is in the leaf's pre-image.
+     *
+     * @return list<bool>
+     */
+    private function membership(Comparison|In $node): array
+    {
+        $resolution = $this->filter->rowLeaf($node);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return array_fill(0, $this->rows, false);
+        }
+
+        /** @var PhysicalIntervals $intervals rowLeaf() resolves only leaves answered exactly */
+        $intervals = $resolution->intervals;
+        $result = [];
+
+        /** @var null|bool|float|int|string $value contains() refuses any other */
+        foreach ($this->values($resolution) as $value) {
+            $result[] = $value !== null && $intervals->contains($value) !== $this->negated;
+        }
+
+        return $result;
+    }
+
+    /**
+     * @return list<mixed>
+     */
+    private function values(ResolvedLeaf $resolution): array
+    {
+        $path = $resolution->column->flatPath();
+
+        if (!array_key_exists($path, $this->physicalByPath)) {
+            throw new InvalidArgumentException('No physical values of column "' . $path . '"');
+        }
+
+        $values = $this->physicalByPath[$path];
+
+        if (count($values) !== $this->rows) {
+            throw new InvalidArgumentException(sprintf(
+                'Column "%s" holds %d physical values for %d rows',
+                $path,
+                count($values),
+                $this->rows,
+            ));
+        }
+
+        return $values;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/RowGroupZoneMaps.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/RowGroupZoneMaps.php
new file mode 100644
index 0000000000..8e39885b32
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/RowGroupZoneMaps.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function array_key_exists;
+
+final class RowGroupZoneMaps implements ZoneMaps
+{
+    /**
+     * @var array<string, null|ZoneMap>
+     */
+    private array $zones = [];
+
+    public function __construct(
+        private readonly RowGroupChunks $chunks,
+        private readonly int $rowGroup,
+    ) {}
+
+    public function zone(FlatColumn $column): ?ZoneMap
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($path, $this->zones)) {
+            $this->zones[$path] = $this->decode($column);
+        }
+
+        return $this->zones[$path];
+    }
+
+    private function decode(FlatColumn $column): ?ZoneMap
+    {
+        $statistics = $this->chunks->chunk($this->rowGroup, $column)->statistics();
+
+        return $statistics === null
+            ? null
+            : ZoneMap::fromStatistics(
+                column: $column,
+                columnOrder: $this->chunks->columnOrder($column),
+                min: $statistics->minValue($column),
+                max: $statistics->maxValue($column),
+                minExact: $statistics->isMinValueExact(),
+                maxExact: $statistics->isMaxValueExact(),
+                nullCount: $statistics->nullCount(),
+                nanCount: $statistics->nanCount(),
+                rowCount: $this->chunks->rowCounts()[$this->rowGroup],
+            );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/StatisticsEvaluator.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/StatisticsEvaluator.php
new file mode 100644
index 0000000000..bc79fca806
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/StatisticsEvaluator.php
@@ -0,0 +1,195 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Binding\AbsentLeaf;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\FilterVisitor;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\Filter\StartsWith;
+use Flow\Parquet\Filter\Truth;
+use Generator;
+
+/**
+ * @implements FilterVisitor<Truth>
+ */
+final readonly class StatisticsEvaluator implements FilterVisitor
+{
+    private function __construct(
+        private BoundFilter $filter,
+        private ZoneMaps $zones,
+        private bool $negated = false,
+    ) {}
+
+    public static function evaluate(BoundFilter $filter, ZoneMaps $zones): Truth
+    {
+        return $filter->filter()->accept(new self($filter, $zones));
+    }
+
+    public function comparison(Comparison $comparison): Truth
+    {
+        return $this->membership($comparison, $comparison->operator === Operator::Equal);
+    }
+
+    public function all(All $all): Truth
+    {
+        return $this->negated ? Truth::some($this->truths($all->filters)) : Truth::every($this->truths($all->filters));
+    }
+
+    public function any(Any $any): Truth
+    {
+        return $this->negated ? Truth::every($this->truths($any->filters)) : Truth::some($this->truths($any->filters));
+    }
+
+    public function in(In $in): Truth
+    {
+        return $this->membership($in, true);
+    }
+
+    public function isNull(IsNull $isNull): Truth
+    {
+        $resolution = $this->filter->leaf($isNull);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return $this->negated ? Truth::Never : Truth::Always;
+        }
+
+        $zone = $resolution instanceof ResolvedLeaf ? $this->zones->zone($resolution->column) : null;
+
+        if ($zone === null) {
+            return Truth::Maybe;
+        }
+
+        [$never, $always] = $this->negated
+            ? [self::allNull($zone), $zone->nullCount === 0]
+            : [$zone->nullCount === 0, self::allNull($zone)];
+
+        return self::truth($never, $always);
+    }
+
+    public function not(Not $not): Truth
+    {
+        return $not->filter->accept(new self($this->filter, $this->zones, !$this->negated));
+    }
+
+    public function startsWith(StartsWith $startsWith): Truth
+    {
+        $resolution = $this->filter->leaf($startsWith);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return Truth::Never;
+        }
+
+        if (!$resolution instanceof ResolvedLeaf || $resolution->intervals === null) {
+            return Truth::Maybe;
+        }
+
+        $intervals = $resolution->intervals;
+        $zone = $this->zones->zone($resolution->column);
+
+        if ($zone !== null && self::allNull($zone)) {
+            return Truth::Never;
+        }
+
+        if ($zone === null || $zone->min === null || $zone->max === null) {
+            return Truth::Maybe;
+        }
+
+        $none = $intervals->disjoint($zone->min, $zone->max);
+        $all = $intervals->covers($zone->min, $zone->max);
+        $noNull = $zone->nullCount === 0;
+
+        return $this->negated ? self::truth($all, $noNull && $none) : self::truth($none, $noNull && $all);
+    }
+
+    /**
+     * Comparison and In: the zone against the leaf's pre-image I.
+     */
+    private function membership(Comparison|In $node, bool $equality): Truth
+    {
+        $resolution = $this->filter->leaf($node);
+
+        if ($resolution instanceof AbsentLeaf) {
+            return Truth::Never;
+        }
+
+        if (!$resolution instanceof ResolvedLeaf || $resolution->intervals === null) {
+            return Truth::Maybe;
+        }
+
+        $intervals = $resolution->intervals;
+        $zone = $this->zones->zone($resolution->column);
+
+        if ($intervals->isEmpty()) {
+            if (!$this->negated) {
+                return Truth::Never;
+            }
+
+            return $zone === null ? Truth::Maybe : self::truth(self::allNull($zone), $zone->nullCount === 0);
+        }
+
+        if ($zone === null) {
+            return Truth::Maybe;
+        }
+
+        if (self::allNull($zone)) {
+            return Truth::Never;
+        }
+
+        $noNull = $zone->nullCount === 0;
+
+        if ($zone->allNaN) {
+            return $this->negated ? self::truth(false, $noNull) : Truth::Never;
+        }
+
+        if ($zone->min === null || $zone->max === null) {
+            return Truth::Maybe;
+        }
+
+        $noNan = !$intervals->order->isFloatingPoint() || $zone->nanCount === 0;
+        $none = $intervals->disjoint($zone->min, $zone->max);
+        $all = (!$equality || $zone->minExact && $zone->maxExact) && $intervals->covers($zone->min, $zone->max);
+
+        return $this->negated
+            ? self::truth($noNan && $all, $noNull && $none)
+            : self::truth($none, $noNull && $noNan && $all);
+    }
+
+    private static function allNull(ZoneMap $zone): bool
+    {
+        return $zone->nullCount === $zone->rowCount;
+    }
+
+    private static function truth(bool $never, bool $always): Truth
+    {
+        return match (true) {
+            $never => Truth::Never,
+            $always => Truth::Always,
+            default => Truth::Maybe,
+        };
+    }
+
+    /**
+     * Each filter's truth, evaluated only when the combinator asks for it.
+     *
+     * @param list<Filter> $filters
+     *
+     * @return Generator<Truth>
+     */
+    private function truths(array $filters): Generator
+    {
+        foreach ($filters as $filter) {
+            yield $filter->accept($this);
+        }
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/ZoneMap.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/ZoneMap.php
new file mode 100644
index 0000000000..7ec9b5f71b
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/ZoneMap.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+/**
+ * $min and $max are decoded physical values the column order trusts, null when there is none. $allNaN: every value
+ * that is not null is NaN.
+ */
+final readonly class ZoneMap
+{
+    public function __construct(
+        public bool|float|int|string|null $min,
+        public bool|float|int|string|null $max,
+        public bool $minExact,
+        public bool $maxExact,
+        public ?int $nullCount,
+        public ?int $nanCount,
+        public int $rowCount,
+        public bool $allNaN,
+    ) {}
+
+    /**
+     * Under IEEE_754_TOTAL_ORDER a writer stores a NaN bound only when every value that is not null is NaN.
+     */
+    public static function fromStatistics(
+        FlatColumn $column,
+        ColumnOrder $columnOrder,
+        bool|float|int|string|null $min,
+        bool|float|int|string|null $max,
+        ?bool $minExact,
+        ?bool $maxExact,
+        ?int $nullCount,
+        ?int $nanCount,
+        int $rowCount,
+    ): self {
+        $order = PhysicalOrder::forColumn($column);
+        $min = $columnOrder->trustedMin($column, $min);
+        $max = $columnOrder->trustedMax($column, $max);
+        $truncatable =
+            $column->type() === PhysicalType::BYTE_ARRAY || $column->type() === PhysicalType::FIXED_LEN_BYTE_ARRAY;
+
+        return new self(
+            min: $min,
+            max: $max,
+            minExact: $minExact ?? !$truncatable,
+            maxExact: $maxExact ?? !$truncatable,
+            nullCount: $nullCount,
+            nanCount: $nanCount,
+            rowCount: $rowCount,
+            allNaN: $columnOrder === ColumnOrder::Ieee754TotalOrder
+            && ($min !== null && $order->isNan($min) || $max !== null && $order->isNan($max)),
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/ZoneMaps.php b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/ZoneMaps.php
new file mode 100644
index 0000000000..a2d93190f0
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Evaluation/ZoneMaps.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter\Evaluation;
+
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+interface ZoneMaps
+{
+    /**
+     * Null when the unit has no usable statistics for the column.
+     */
+    public function zone(FlatColumn $column): ?ZoneMap;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Filter.php b/src/lib/parquet/src/Flow/Parquet/Filter/Filter.php
new file mode 100644
index 0000000000..90a224ab90
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Filter.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+/**
+ * The implementations are closed: All, Any, Comparison, In, IsNull, Not and StartsWith; every walker refuses another.
+ */
+interface Filter
+{
+    /**
+     * @template T
+     *
+     * @param FilterVisitor<T> $visitor
+     *
+     * @return T
+     */
+    public function accept(FilterVisitor $visitor): mixed;
+
+    public function and(self $other): All;
+
+    public function negate(): self;
+
+    public function or(self $other): Any;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/FilterVisitor.php b/src/lib/parquet/src/Flow/Parquet/Filter/FilterVisitor.php
new file mode 100644
index 0000000000..82bc789106
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/FilterVisitor.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+/**
+ * @template T
+ */
+interface FilterVisitor
+{
+    /**
+     * @return T
+     */
+    public function comparison(Comparison $comparison): mixed;
+
+    /**
+     * @return T
+     */
+    public function all(All $all): mixed;
+
+    /**
+     * @return T
+     */
+    public function any(Any $any): mixed;
+
+    /**
+     * @return T
+     */
+    public function in(In $in): mixed;
+
+    /**
+     * @return T
+     */
+    public function isNull(IsNull $isNull): mixed;
+
+    /**
+     * @return T
+     */
+    public function not(Not $not): mixed;
+
+    /**
+     * @return T
+     */
+    public function startsWith(StartsWith $startsWith): mixed;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/In.php b/src/lib/parquet/src/Flow/Parquet/Filter/In.php
new file mode 100644
index 0000000000..c590dd24aa
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/In.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+use DateTimeImmutable;
+
+use function array_map;
+use function array_values;
+
+final readonly class In implements Filter
+{
+    /**
+     * @var list<bool|DateTimeImmutable|float|int|string>
+     */
+    public array $values;
+
+    /**
+     * @param array<mixed> $values
+     */
+    public function __construct(
+        public ColumnRef $column,
+        array $values,
+    ) {
+        $this->values = array_map(Literal::of(...), array_values($values));
+    }
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->in($this);
+    }
+
+    public function and(Filter $other): All
+    {
+        return new All($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return new Not($this);
+    }
+
+    public function or(Filter $other): Any
+    {
+        return new Any($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/IsNull.php b/src/lib/parquet/src/Flow/Parquet/Filter/IsNull.php
new file mode 100644
index 0000000000..ace547384e
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/IsNull.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+final readonly class IsNull implements Filter
+{
+    public function __construct(
+        public ColumnRef $column,
+    ) {}
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->isNull($this);
+    }
+
+    public function and(Filter $other): All
+    {
+        return new All($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return new Not($this);
+    }
+
+    public function or(Filter $other): Any
+    {
+        return new Any($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Literal.php b/src/lib/parquet/src/Flow/Parquet/Filter/Literal.php
new file mode 100644
index 0000000000..2db07e6ae7
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Literal.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+use InvalidArgumentException;
+use Stringable;
+
+use function get_debug_type;
+use function is_bool;
+use function is_float;
+use function is_int;
+use function is_nan;
+use function is_string;
+use function sprintf;
+
+final readonly class Literal
+{
+    private function __construct() {}
+
+    public static function of(mixed $value): bool|DateTimeImmutable|float|int|string
+    {
+        return match (true) {
+            $value === null => throw new InvalidArgumentException('A filter literal cannot be null, use isNull()'),
+            is_float($value) && is_nan($value) => throw new InvalidArgumentException('A filter literal cannot be NaN'),
+            is_bool($value), is_float($value), is_int($value), is_string($value) => $value,
+            $value instanceof DateTimeInterface => DateTimeImmutable::createFromInterface($value),
+            $value instanceof Stringable => (string) $value,
+            default => throw new InvalidArgumentException(sprintf(
+                'A filter literal must be a scalar, a DateTimeInterface or a Stringable, %s given',
+                get_debug_type($value),
+            )),
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Not.php b/src/lib/parquet/src/Flow/Parquet/Filter/Not.php
new file mode 100644
index 0000000000..dc9b3e3a86
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Not.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+final readonly class Not implements Filter
+{
+    public function __construct(
+        public Filter $filter,
+    ) {}
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->not($this);
+    }
+
+    public function and(Filter $other): All
+    {
+        return new All($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return $this->filter;
+    }
+
+    public function or(Filter $other): Any
+    {
+        return new Any($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Operator.php b/src/lib/parquet/src/Flow/Parquet/Filter/Operator.php
new file mode 100644
index 0000000000..8f342bae92
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Operator.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+enum Operator
+{
+    case Equal;
+    case GreaterThan;
+    case GreaterThanOrEqual;
+    case LessThan;
+    case LessThanOrEqual;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/StartsWith.php b/src/lib/parquet/src/Flow/Parquet/Filter/StartsWith.php
new file mode 100644
index 0000000000..90b9d0f3be
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/StartsWith.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+final readonly class StartsWith implements Filter
+{
+    public function __construct(
+        public ColumnRef $column,
+        public string $prefix,
+    ) {}
+
+    public function accept(FilterVisitor $visitor): mixed
+    {
+        return $visitor->startsWith($this);
+    }
+
+    public function and(Filter $other): All
+    {
+        return new All($this, $other);
+    }
+
+    public function negate(): Filter
+    {
+        return new Not($this);
+    }
+
+    public function or(Filter $other): Any
+    {
+        return new Any($this, $other);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Filter/Truth.php b/src/lib/parquet/src/Flow/Parquet/Filter/Truth.php
new file mode 100644
index 0000000000..8260932240
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Filter/Truth.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Filter;
+
+enum Truth
+{
+    case Always;
+    case Maybe;
+    case Never;
+
+    /**
+     * AND: Never as soon as one is Never, Always only when all are.
+     *
+     * @param iterable<Truth> $truths
+     */
+    public static function every(iterable $truths): self
+    {
+        $truth = self::Always;
+
+        foreach ($truths as $child) {
+            if ($child === self::Never) {
+                return self::Never;
+            }
+
+            if ($child === self::Maybe) {
+                $truth = self::Maybe;
+            }
+        }
+
+        return $truth;
+    }
+
+    /**
+     * OR: Always as soon as one is Always, Never only when all are.
+     *
+     * @param iterable<Truth> $truths
+     */
+    public static function some(iterable $truths): self
+    {
+        $truth = self::Never;
+
+        foreach ($truths as $child) {
+            if ($child === self::Always) {
+                return self::Always;
+            }
+
+            if ($child === self::Maybe) {
+                $truth = self::Maybe;
+            }
+        }
+
+        return $truth;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Option.php b/src/lib/parquet/src/Flow/Parquet/Option.php
index b3caeefde9..5332d048a6 100644
--- a/src/lib/parquet/src/Flow/Parquet/Option.php
+++ b/src/lib/parquet/src/Flow/Parquet/Option.php
@@ -6,17 +6,6 @@
 
 enum Option
 {
-    /**
-     * When using the Arrow engine, controls how many rows are returned per internal read call.
-     * Reduces peak memory usage for large row groups by streaming batches of this size.
-     *
-     * Only affects the Arrow engine. Ignored by the PHP engine.
-     * Set to null to read entire row groups at once (maximum throughput).
-     *
-     * Default: 1024
-     */
-    case ARROW_BATCH_SIZE;
-
     /**
      * When using the Arrow engine, controls how many rows are buffered in PHP
      * before sending them to the extension's writeBatch() in a single call.
@@ -51,6 +40,23 @@ enum Option
      */
     case COLUMNS_COMPRESSIONS;
 
+    /**
+     * Per-column bloom filter configuration using flat path notation.
+     * Accepts array<string, BloomFilterOptions> where key is column flat path and value is the filter's false positive
+     * probability and expected distinct values.
+     *
+     * Flat path examples:
+     * - Simple columns: 'column_name'
+     * - Nested structs: 'user.address.street'
+     * - List elements: 'items.list.element'
+     * - Map keys/values: 'metadata.key_value.key', 'metadata.key_value.value'
+     *
+     * Values must be BloomFilterOptions instances. Readers use the filters for equality and in predicates only.
+     *
+     * Default: null (no bloom filters)
+     */
+    case COLUMNS_BLOOM_FILTERS;
+
     /**
      * Per-column encoding configuration using flat path notation.
      * Accepts array<string, Encodings> where key is column flat path and value is encoding enum.
@@ -68,14 +74,12 @@ enum Option
     case COLUMNS_ENCODINGS;
 
     /**
-     * Whenever cardinality ratio of the dictionary goes below this value, PagesBuilders is going to fallback to PLAIN encoding.
-     * Cardinality ration is calculated as distinct values / total values.
-     * Please notice that even when cardinality ration is above this value, PageBuilder will still fallback to PLAIN encoding
-     * when dictionary size gets above DICTIONARY_PAGE_SIZE.
+     * Column index bounds of BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY columns are truncated to this many bytes, as
+     * STATISTICS_TRUNCATE_LENGTH truncates column chunk statistics (arrow-rs set_column_index_truncate_length).
      *
-     * Default value 0.4 (40% of the total values is distinct)
+     * Default value is 64
      */
-    case DICTIONARY_PAGE_MIN_CARDINALITY_RATION;
+    case COLUMN_INDEX_TRUNCATE_LENGTH;
 
     /**
      * Whenever size of the dictionary goes above this value, PagesBuilders is going to fallback to PLAIN encoding.
@@ -115,8 +119,17 @@ enum Option
     case LZ4_COMPRESSION_LEVEL;
 
     /**
-     * PageBuilder is going to use this value to determine how many rows should be stored in one page.
-     * Smaller pages will reduce memory usage, but will increase the number of pages in the file increasing the IO operations.
+     * Data page headers carry the page's statistics when the statistics level is PAGE, as arrow-rs
+     * set_write_page_header_statistics. Readers prune pages through the column index instead.
+     *
+     * Default value is false
+     */
+    case PAGE_HEADER_STATISTICS;
+
+    /**
+     * The rows a data page holds at most, beside PAGE_SIZE_BYTES (arrow-rs data_page_row_count_limit). The PHP writer
+     * checks it every PAGE_SIZE_CHECK_INTERVAL rows, the arrow writer every write batch. Smaller pages let the page
+     * index skip more of a filtered read, at the cost of more page headers.
      *
      * Default value is 1000 rows
      */
@@ -162,6 +175,23 @@ enum Option
      */
     case ROW_GROUP_SIZE_CHECK_INTERVAL;
 
+    /**
+     * A Writer\StatisticsLevel: NONE writes no statistics, CHUNK writes column chunk statistics, PAGE also writes a
+     * column index (per page min, max, null and NaN counts). The offset index is written at every level.
+     *
+     * Default value is StatisticsLevel::PAGE
+     */
+    case STATISTICS_LEVEL;
+
+    /**
+     * Column chunk and page statistics of BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY columns are truncated to this many bytes,
+     * as arrow-rs does: the min is cut, the max is cut and incremented, and a truncated bound is marked inexact.
+     * Decimals and FLOAT16 are never truncated.
+     *
+     * Default value is 64
+     */
+    case STATISTICS_TRUNCATE_LENGTH;
+
     /**
      * This option is going to tell the writer to validate data against schema.
      * In most cases that should be enabled, however if performance is critical, it can be disabled.
diff --git a/src/lib/parquet/src/Flow/Parquet/Options.php b/src/lib/parquet/src/Flow/Parquet/Options.php
index f64ae97ace..edfd30ddde 100644
--- a/src/lib/parquet/src/Flow/Parquet/Options.php
+++ b/src/lib/parquet/src/Flow/Parquet/Options.php
@@ -6,7 +6,10 @@
 
 use Flow\Filesystem\SizeUnits;
 use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Writer\StatisticsLevel;
+use UnitEnum;
 
+use function get_debug_type;
 use function gettype;
 use function is_array;
 use function is_bool;
@@ -16,14 +19,13 @@
 final class Options
 {
     /**
-     * @var array<string, null|array<mixed>|bool|float|int|string>
+     * @var array<string, null|array<mixed>|bool|float|int|string|UnitEnum>
      */
     private array $options;
 
     public function __construct()
     {
         $this->options = [
-            Option::ARROW_BATCH_SIZE->name => 1024,
             Option::ARROW_WRITE_BATCH_SIZE->name => 1000,
             Option::INT_96_AS_DATETIME->name => true,
             Option::PAGE_MAXIMUM_ROWS_COUNT->name => 1000,
@@ -31,8 +33,11 @@ public function __construct()
             Option::PAGE_SIZE_CHECK_INTERVAL->name => 100,
             Option::ROW_GROUP_SIZE_BYTES->name => SizeUnits::MiB_SIZE * 32,
             Option::ROW_GROUP_SIZE_CHECK_INTERVAL->name => 1000,
+            Option::STATISTICS_LEVEL->name => StatisticsLevel::PAGE,
+            Option::STATISTICS_TRUNCATE_LENGTH->name => 64,
+            Option::COLUMN_INDEX_TRUNCATE_LENGTH->name => 64,
+            Option::PAGE_HEADER_STATISTICS->name => false,
             Option::DICTIONARY_PAGE_SIZE->name => SizeUnits::MiB_SIZE,
-            Option::DICTIONARY_PAGE_MIN_CARDINALITY_RATION->name => 0.4,
             Option::BROTLI_COMPRESSION_LEVEL->name => 11,
             Option::GZIP_COMPRESSION_LEVEL->name => 9,
             Option::LZ4_COMPRESSION_LEVEL->name => 4,
@@ -41,6 +46,7 @@ public function __construct()
             Option::VALIDATE_DATA->name => true,
             Option::COLUMNS_ENCODINGS->name => null,
             Option::COLUMNS_COMPRESSIONS->name => null,
+            Option::COLUMNS_BLOOM_FILTERS->name => null,
         ];
     }
 
@@ -50,9 +56,9 @@ public static function default(): self
     }
 
     /**
-     * @return null|array<mixed>|bool|float|int|string
+     * @return null|array<mixed>|bool|float|int|string|UnitEnum
      */
-    public function get(Option $option): bool|int|float|string|array|null
+    public function get(Option $option): bool|int|float|string|array|UnitEnum|null
     {
         return $this->options[$option->name];
     }
@@ -86,6 +92,26 @@ public function getBool(Option $option): bool
         return $value;
     }
 
+    /**
+     * @template T of UnitEnum
+     *
+     * @param class-string<T> $class
+     *
+     * @return T
+     */
+    public function getEnum(Option $option, string $class): UnitEnum
+    {
+        $value = $this->options[$option->name];
+
+        if (!$value instanceof $class) {
+            throw new InvalidArgumentException(
+                "Option {$option->name} is not a {$class}, but: " . get_debug_type($value),
+            );
+        }
+
+        return $value;
+    }
+
     public function getInt(Option $option): int
     {
         $value = $this->options[$option->name];
@@ -116,9 +142,9 @@ public function has(Option $option): bool
     }
 
     /**
-     * @param null|array<mixed>|bool|float|int|string $value
+     * @param null|array<mixed>|bool|float|int|string|UnitEnum $value
      */
-    public function set(Option $option, bool|int|float|string|array|null $value): self
+    public function set(Option $option, bool|int|float|string|array|UnitEnum|null $value): self
     {
         $this->options[$option->name] = $value;
 
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile.php
index b654c2482f..e1f0614d34 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile.php
@@ -6,12 +6,18 @@
 
 use Flow\Filesystem\SourceStream;
 use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\FilterEvaluator;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\ParquetFile\Index\StreamIndexes;
 use Flow\Parquet\ParquetFile\Metadata;
 use Flow\Parquet\ParquetFile\Page\ColumnPageHeader;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\Column;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\Reader\ColumnChunkViewer;
+use Flow\Parquet\Reader\FilteredBatches;
+use Flow\Parquet\Reader\ReadPlanner;
 use Generator;
 
 use function array_keys;
@@ -26,10 +32,12 @@ final class ParquetFile
 {
     public const string PARQUET_MAGIC_NUMBER = 'PAR1';
 
-    private const int VALUES_BATCH_SIZE = 1024;
+    private const int BATCH_SIZE = 1024;
 
     private bool $closed = false;
 
+    private ?Indexes $indexes = null;
+
     /**
      * @param R $reader opened on $stream
      */
@@ -54,9 +62,22 @@ public function close(): void
         $this->reader->close();
     }
 
+    /**
+     * The page indexes, read from the file on first access.
+     */
+    public function indexes(): Indexes
+    {
+        return $this->indexes ??= new StreamIndexes($this->reader->footer(), $this->stream);
+    }
+
     public function metadata(): Metadata
     {
-        return $this->reader->metadata();
+        return $this->reader->footer()->metadata();
+    }
+
+    public function options(): Options
+    {
+        return $this->options;
     }
 
     /**
@@ -81,49 +102,73 @@ public function reader(): ParquetFileReader
 
     public function schema(): Schema
     {
-        return $this->reader->schema();
+        return $this->reader->footer()->schema();
     }
 
     /**
-     * @param array<string> $columns
+     * The reader keeps the rows of the filter's bound conjuncts, the rest are evaluated here; offset and limit count the
+     * rows returned.
      *
      * @return Generator<int, array<string, list<mixed>>>
      */
-    public function columns(int $batchSize, array $columns = [], ?int $limit = null, ?int $offset = null): Generator
+    public function columns(Query $query = new Query(), int $batchSize = self::BATCH_SIZE): Generator
     {
         if ($batchSize < 1) {
             throw new InvalidArgumentException('Batch size must be greater than 0');
         }
 
-        if ($limit !== null && $limit <= 0) {
-            throw new InvalidArgumentException('Limit must be greater than 0');
-        }
+        $schema = $this->schema();
+        $columns = $query->columns === []
+            ? array_values(array_map(static fn(Column $column): string => $column->name(), $schema->columns()))
+            : $query->columns;
 
-        if ($offset !== null && $offset < 0) {
-            throw new InvalidArgumentException('Offset must be greater than or equal to 0');
+        foreach ($columns as $column) {
+            if (!$schema->has($column)) {
+                throw new InvalidArgumentException("Column \"{$column}\" does not exist");
+            }
         }
 
-        if (!count($columns)) {
-            $columns = array_map(static fn(Column $c) => $c->name(), $this->schema()->columns());
-        }
+        $filter = $query->filter === null ? null : BoundFilter::bind($query->filter, $schema, $this->options);
+        // a filtered plan counts matching rows from the start, so the offset is applied here; it takes the limit only
+        // when it answers every conjunct, otherwise the residual ones below decide which rows count
+        $plan = (new ReadPlanner())->plan(
+            $this->reader->footer(),
+            $this->indexes(),
+            $filter,
+            $filter === null ? $query->offset : 0,
+            match (true) {
+                $filter === null => $query->limit,
+                $filter->answersEveryConjunct() && $query->limit !== null => $query->offset + $query->limit,
+                default => null,
+            },
+        );
+
+        if ($filter === null) {
+            yield from $this->reader->readColumns($columns, $batchSize, $plan);
 
-        foreach ($columns as $columnName) {
-            if (!$this->schema()->has($columnName)) {
-                throw new InvalidArgumentException("Column \"{$columnName}\" does not exist");
-            }
+            return;
         }
 
-        yield from $this->reader->readColumns(array_values($columns), $batchSize, $limit, $offset);
+        $residual = $filter->residual();
+        $filtered = new FilteredBatches(
+            $residual === null ? null : new FilterEvaluator($residual),
+            $columns,
+            $query->offset,
+            $query->limit,
+            $batchSize,
+        );
+
+        yield from $filtered->filter($this->reader->readColumns($filtered->columns(), $batchSize, $plan));
     }
 
     /**
-     * @param array<string> $columns
+     * The query's rows one by one, keyed by column.
      *
      * @return Generator<int, array<string, mixed>>
      */
-    public function values(array $columns = [], ?int $limit = null, ?int $offset = null): Generator
+    public function values(Query $query = new Query()): Generator
     {
-        foreach ($this->columns(self::VALUES_BATCH_SIZE, $columns, $limit, $offset) as $chunk) {
+        foreach ($this->columns($query) as $chunk) {
             $names = array_keys($chunk);
             $count = count($chunk[$names[0]]);
 
@@ -147,10 +192,10 @@ private function viewChunksPages(FlatColumn $column): Generator
         $viewer = new ColumnChunkViewer($this->options);
 
         foreach ($this->metadata()->rowGroups()->all() as $rowGroup) {
-            foreach ($rowGroup->columnChunks() as $columnChunk) {
-                foreach ($viewer->view($columnChunk, $this->stream) as $pageHeader) {
-                    yield new ColumnPageHeader($column, $columnChunk, $pageHeader);
-                }
+            $columnChunk = $rowGroup->getColumnChunk($column);
+
+            foreach ($viewer->view($columnChunk, $this->stream) as $pageHeader) {
+                yield new ColumnPageHeader($column, $columnChunk, $pageHeader);
             }
         }
     }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/ColumnOrder.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/ColumnOrder.php
new file mode 100644
index 0000000000..08f8312c59
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/ColumnOrder.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile;
+
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ThriftModel\ColumnOrder as ThriftColumnOrder;
+use Flow\Parquet\ThriftModel\IEEE754TotalOrder;
+use Flow\Parquet\ThriftModel\Int96TimestampOrder;
+use Flow\Parquet\ThriftModel\TypeDefinedOrder;
+
+enum ColumnOrder
+{
+    case Absent;
+    case Ieee754TotalOrder;
+    case Int96Timestamp;
+    case TypeDefined;
+    case Unknown;
+
+    public static function forWriting(FlatColumn $column): self
+    {
+        if (PhysicalOrder::forColumn($column)->isFloatingPoint()) {
+            return self::Ieee754TotalOrder;
+        }
+
+        if ($column->type() === PhysicalType::INT96) {
+            return self::Int96Timestamp;
+        }
+
+        return self::TypeDefined;
+    }
+
+    public static function fromThrift(?ThriftColumnOrder $order): self
+    {
+        if ($order === null) {
+            return self::Absent;
+        }
+
+        return match (true) {
+            $order->TYPE_ORDER !== null => self::TypeDefined,
+            $order->IEEE_754_TOTAL_ORDER !== null => self::Ieee754TotalOrder,
+            $order->INT96_TIMESTAMP_ORDER !== null => self::Int96Timestamp,
+            default => self::Unknown,
+        };
+    }
+
+    public function isTrusted(FlatColumn $column): bool
+    {
+        if (PhysicalOrder::forColumn($column)->isUnordered()) {
+            return false;
+        }
+
+        return match ($this) {
+            self::TypeDefined, self::Ieee754TotalOrder => true,
+            self::Absent, self::Int96Timestamp, self::Unknown => false,
+        };
+    }
+
+    public function toThrift(): ThriftColumnOrder
+    {
+        return match ($this) {
+            self::TypeDefined => new ThriftColumnOrder(['TYPE_ORDER' => new TypeDefinedOrder()]),
+            self::Ieee754TotalOrder => new ThriftColumnOrder(['IEEE_754_TOTAL_ORDER' => new IEEE754TotalOrder()]),
+            self::Int96Timestamp => new ThriftColumnOrder(['INT96_TIMESTAMP_ORDER' => new Int96TimestampOrder()]),
+            self::Unknown => new ThriftColumnOrder(),
+            self::Absent => throw new InvalidArgumentException('Column order Absent cannot be written'),
+        };
+    }
+
+    /**
+     * The statistics max a reader may use, null when it may not. Under TYPE_DEFINED_ORDER a floating point max of NaN
+     * is ignored and a -0.0 max may hide +0.0 values (parquet.thrift ColumnOrder).
+     */
+    public function trustedMax(FlatColumn $column, bool|float|int|string|null $max): bool|float|int|string|null
+    {
+        if ($max === null || !$this->isTrusted($column)) {
+            return null;
+        }
+
+        $order = PhysicalOrder::forColumn($column);
+
+        if ($this !== self::TypeDefined || !$order->isFloatingPoint()) {
+            return $max;
+        }
+
+        return match (true) {
+            $order->isNan($max) => null,
+            $order->isZero($max) => $order->zero(negative: false),
+            default => $max,
+        };
+    }
+
+    /**
+     * The statistics min a reader may use, null when it may not. Under TYPE_DEFINED_ORDER a floating point min of NaN
+     * is ignored and a +0.0 min may hide -0.0 values (parquet.thrift ColumnOrder).
+     */
+    public function trustedMin(FlatColumn $column, bool|float|int|string|null $min): bool|float|int|string|null
+    {
+        if ($min === null || !$this->isTrusted($column)) {
+            return null;
+        }
+
+        $order = PhysicalOrder::forColumn($column);
+
+        if ($this !== self::TypeDefined || !$order->isFloatingPoint()) {
+            return $min;
+        }
+
+        return match (true) {
+            $order->isNan($min) => null,
+            $order->isZero($min) => $order->zero(negative: true),
+            default => $min,
+        };
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/DecimalConverter.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/DecimalConverter.php
index dbeff12bc4..01da91087c 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/DecimalConverter.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/DecimalConverter.php
@@ -4,6 +4,7 @@
 
 namespace Flow\Parquet\ParquetFile\Data\Converter;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Data\Converter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
@@ -11,32 +12,56 @@
 
 use function Flow\Parquet\Binary\decimal_from_unscaled;
 use function Flow\Parquet\Binary\decimal_unscaled;
+use function Flow\Parquet\Binary\decode_decimal;
+use function Flow\Parquet\Binary\encode_decimal;
+use function get_debug_type;
+use function is_float;
+use function is_int;
 
 final readonly class DecimalConverter implements Converter
 {
     public function __construct(
+        private PhysicalType $physicalType,
         private int $precision,
         private int $scale,
+        private ?int $byteLength = null,
     ) {}
 
     public static function forColumn(FlatColumn $column, Options $options): ?self
     {
         $decimal = $column->logicalType()?->decimalData();
 
-        return ($column->type() === PhysicalType::INT32 || $column->type() === PhysicalType::INT64) && $decimal !== null
-            ? new self($decimal->precision(), $decimal->scale())
+        return $decimal !== null && $column->type() !== PhysicalType::INT96
+            ? new self(
+                $column->type(),
+                $decimal->precision(),
+                $decimal->scale(),
+                $column->type() === PhysicalType::FIXED_LEN_BYTE_ARRAY ? $column->typeLength() : null,
+            )
             : null;
     }
 
     public function fromParquetType(mixed $data): float
     {
-        /** @var int $data */
-        return decimal_from_unscaled((string) $data, $this->scale);
+        /** @var int|string $data */
+        return is_int($data)
+            ? decimal_from_unscaled((string) $data, $this->scale)
+            : decode_decimal($data, $this->scale);
     }
 
-    public function toParquetType(mixed $data): int
+    public function toParquetType(mixed $data): int|string
     {
-        /** @var float|int $data */
-        return (int) decimal_unscaled((float) $data, $this->precision, $this->scale);
+        if (!is_int($data) && !is_float($data)) {
+            throw new InvalidArgumentException('Decimal must be written as int or float, got ' . get_debug_type($data));
+        }
+
+        return match ($this->physicalType) {
+            PhysicalType::INT32, PhysicalType::INT64 => (int) decimal_unscaled(
+                (float) $data,
+                $this->precision,
+                $this->scale,
+            ),
+            default => encode_decimal((float) $data, $this->precision, $this->scale, $this->byteLength),
+        };
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedIntegerConverter.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedInt32Converter.php
similarity index 50%
rename from src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedIntegerConverter.php
rename to src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedInt32Converter.php
index 6d15ddd70b..c7b2e2e12b 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedIntegerConverter.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedInt32Converter.php
@@ -5,7 +5,6 @@
 namespace Flow\Parquet\ParquetFile\Data\Converter;
 
 use Flow\Parquet\Exception\InvalidArgumentException;
-use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Data\Converter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
@@ -15,22 +14,11 @@
 use function is_int;
 use function sprintf;
 
-final readonly class UnsignedIntegerConverter implements Converter
+final readonly class UnsignedInt32Converter implements Converter
 {
-    public function __construct(
-        private string $path,
-        private int $bitWidth,
-    ) {}
-
     public static function forColumn(FlatColumn $column, Options $options): ?self
     {
-        $integer = Integer::forColumn($column);
-
-        return $integer !== null
-        && !$integer->isSigned()
-        && ($integer->bitWidth() === 32 || $integer->bitWidth() === 64)
-            ? new self($column->flatPath(), $integer->bitWidth())
-            : null;
+        return Integer::forColumn($column)?->is(32, false) === true ? new self() : null;
     }
 
     public function fromParquetType(mixed $data): int
@@ -39,15 +27,7 @@ public function fromParquetType(mixed $data): int
             throw new InvalidArgumentException(sprintf('Expected int, got %s', get_debug_type($data)));
         }
 
-        if ($data >= 0) {
-            return $data;
-        }
-
-        if ($this->bitWidth === 32) {
-            return $data + 4_294_967_296;
-        }
-
-        throw new RuntimeException(sprintf('Parquet column "%s" holds a UINT_64 value above PHP_INT_MAX', $this->path));
+        return $data >= 0 ? $data : $data + 4_294_967_296;
     }
 
     public function toParquetType(mixed $data): mixed
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedInt64Converter.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedInt64Converter.php
new file mode 100644
index 0000000000..d9ba4b5a1f
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UnsignedInt64Converter.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\Data\Converter;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\Converter;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Integer;
+
+use function bcsub;
+use function ctype_digit;
+use function get_debug_type;
+use function is_int;
+use function is_string;
+use function sprintf;
+use function strcmp;
+use function strlen;
+
+/**
+ * UINT_64: the physical value is the INT64 bit pattern, the logical value its canonical decimal digit string.
+ */
+final readonly class UnsignedInt64Converter implements Converter
+{
+    public const string MAX = '18446744073709551615';
+
+    private const string TWO_POW_64 = '18446744073709551616';
+
+    private const string PHP_INT_MAX = '9223372036854775807';
+
+    public static function forColumn(FlatColumn $column, Options $options): ?self
+    {
+        return Integer::forColumn($column)?->is(64, false) === true ? new self() : null;
+    }
+
+    public function fromParquetType(mixed $data): string
+    {
+        if (!is_int($data)) {
+            throw new InvalidArgumentException(sprintf('Expected int, got %s', get_debug_type($data)));
+        }
+
+        return sprintf('%u', $data);
+    }
+
+    /**
+     * An int >= 0, or a canonical digit string (no sign, no leading zero) up to 18446744073709551615.
+     *
+     * @assert-if-true non-negative-int|numeric-string $data
+     */
+    public static function accepts(mixed $data): bool
+    {
+        if (is_int($data)) {
+            return $data >= 0;
+        }
+
+        return (
+            is_string($data)
+            && ctype_digit($data)
+            && (strlen($data) === 1 || $data[0] !== '0')
+            && !self::exceeds($data, self::MAX)
+        );
+    }
+
+    public function toParquetType(mixed $data): int
+    {
+        if (is_int($data) && $data >= 0) {
+            return $data;
+        }
+
+        if (!self::accepts($data)) {
+            throw new InvalidArgumentException(sprintf(
+                'Expected an int >= 0 or a digit string up to %s, got %s',
+                self::MAX,
+                is_int($data) || is_string($data) ? $data : get_debug_type($data),
+            ));
+        }
+
+        return self::exceeds($data, self::PHP_INT_MAX) ? (int) bcsub($data, self::TWO_POW_64) : (int) $data;
+    }
+
+    private static function exceeds(string $digits, string $limit): bool
+    {
+        return strlen($digits) > strlen($limit) || strlen($digits) === strlen($limit) && strcmp($digits, $limit) > 0;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UuidConverter.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UuidConverter.php
index 2397bce772..b89995dac2 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UuidConverter.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/Converter/UuidConverter.php
@@ -11,11 +11,17 @@
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Stringable;
 
+use function bin2hex;
+use function ctype_xdigit;
 use function get_debug_type;
+use function hex2bin;
 use function is_object;
 use function is_string;
 use function method_exists;
 use function sprintf;
+use function str_replace;
+use function strlen;
+use function substr;
 
 final readonly class UuidConverter implements Converter
 {
@@ -26,32 +32,42 @@ public static function forColumn(FlatColumn $column, Options $options): ?self
 
     public function fromParquetType(mixed $data): string
     {
-        if (!is_string($data)) {
-            throw new RuntimeException('UUID must be read as a string from Parquet file');
+        if (!is_string($data) || strlen($data) !== 16) {
+            throw new RuntimeException('UUID must be read as 16 bytes from Parquet file');
         }
 
-        return $data;
+        $hex = bin2hex($data);
+
+        return sprintf(
+            '%s-%s-%s-%s-%s',
+            substr($hex, 0, 8),
+            substr($hex, 8, 4),
+            substr($hex, 12, 4),
+            substr($hex, 16, 4),
+            substr($hex, 20, 12),
+        );
     }
 
     public function toParquetType(mixed $data): string
     {
-        if (is_string($data)) {
-            return $data;
-        }
-
-        if (is_object($data) && method_exists($data, 'toString')) {
-            return is_string($data->toString())
+        $uuid = match (true) {
+            is_string($data) => $data,
+            is_object($data) && method_exists($data, 'toString') => is_string($data->toString())
                 ? (string) $data->toString()
                 : throw new RuntimeException(sprintf(
                     'UUID toString() must return string, got %s',
                     get_debug_type($data->toString()),
-                ));
-        }
+                )),
+            $data instanceof Stringable => (string) $data,
+            default => throw new RuntimeException('UUID must be written as a string or Stringable object'),
+        };
+
+        $hex = str_replace('-', '', $uuid);
 
-        if ($data instanceof Stringable) {
-            return (string) $data;
+        if (strlen($hex) !== 32 || !ctype_xdigit($hex)) {
+            throw new RuntimeException('Invalid UUID format: ' . $uuid);
         }
 
-        throw new RuntimeException('UUID must be written as a string or Stringable object');
+        return (string) hex2bin($hex);
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/DataConverter.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/DataConverter.php
index 01cafab35c..8b01ed187c 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/DataConverter.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Data/DataConverter.php
@@ -12,7 +12,8 @@
 use Flow\Parquet\ParquetFile\Data\Converter\Int96DateTimeConverter;
 use Flow\Parquet\ParquetFile\Data\Converter\JsonConverter;
 use Flow\Parquet\ParquetFile\Data\Converter\TimeConverter;
-use Flow\Parquet\ParquetFile\Data\Converter\UnsignedIntegerConverter;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt32Converter;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt64Converter;
 use Flow\Parquet\ParquetFile\Data\Converter\UuidConverter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Throwable;
@@ -46,7 +47,8 @@ public static function initialize(Options $options): self
             DecimalConverter::class,
             UuidConverter::class,
             JsonConverter::class,
-            UnsignedIntegerConverter::class,
+            UnsignedInt32Converter::class,
+            UnsignedInt64Converter::class,
         ], $options);
     }
 
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Footer.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Footer.php
new file mode 100644
index 0000000000..2f6aca5432
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Footer.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile;
+
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function interface_exists;
+
+if (interface_exists(Footer::class, false)) {
+    return;
+}
+
+interface Footer
+{
+    /**
+     * The whole footer as Metadata, built on the first call.
+     */
+    public function metadata(): Metadata;
+
+    /**
+     * The footer narrowed to the given leaves, without building the row-group metadata of other columns.
+     *
+     * @param list<FlatColumn> $columns
+     */
+    public function rowGroupChunks(array $columns): RowGroupChunks;
+
+    public function rowsNumber(): int;
+
+    /**
+     * The file schema, without building the row-group metadata.
+     */
+    public function schema(): Schema;
+
+    /**
+     * Σ row group total_byte_size (uncompressed), without building the row-group metadata.
+     */
+    public function totalByteSize(): int;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/IndexLocation.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/IndexLocation.php
new file mode 100644
index 0000000000..bfbc5385cc
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/IndexLocation.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\Index;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+
+/**
+ * Where a column chunk's column index or offset index is written.
+ */
+final readonly class IndexLocation
+{
+    /**
+     * @var positive-int
+     */
+    public int $length;
+
+    /**
+     * @var non-negative-int
+     */
+    public int $offset;
+
+    public function __construct(int $offset, int $length)
+    {
+        if ($offset < 0 || $length < 1) {
+            throw new InvalidArgumentException(
+                'An index location needs an offset of at least 0 and a length of at least 1, got '
+                . $offset
+                . ' and '
+                . $length,
+            );
+        }
+
+        $this->offset = $offset;
+        $this->length = $length;
+    }
+
+    /**
+     * Null when the chunk has no such index, or a location no index can be read from.
+     */
+    public static function fromThrift(int|string|null $offset, int|string|null $length): ?self
+    {
+        if ($offset === null || $length === null || (int) $offset < 0 || (int) $length < 1) {
+            return null;
+        }
+
+        return new self((int) $offset, (int) $length);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/Indexes.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/Indexes.php
new file mode 100644
index 0000000000..664510db35
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/Indexes.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\Index;
+
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+interface Indexes
+{
+    /**
+     * Null when the chunk has no bloom filter, or one of an algorithm, hash or compression this reader does not support.
+     */
+    public function bloomFilter(int $rowGroup, FlatColumn $column): ?Sbbf;
+
+    /**
+     * Null when the chunk has no column index, or one that fails to decode.
+     */
+    public function columnIndex(int $rowGroup, FlatColumn $column): ?ColumnIndex;
+
+    /**
+     * Null when the chunk has no offset index, or one that fails to decode or does not fit the chunk and its row group.
+     */
+    public function offsetIndex(int $rowGroup, FlatColumn $column): ?OffsetIndex;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/StreamIndexes.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/StreamIndexes.php
new file mode 100644
index 0000000000..5569f6b133
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Index/StreamIndexes.php
@@ -0,0 +1,137 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\Index;
+
+use Flow\Filesystem\SourceStream;
+use Flow\Parquet\BloomFilter\BloomFilterReader;
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\ParquetFile\Footer;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
+use Flow\Parquet\ThriftModel\ColumnIndex as ThriftColumnIndex;
+use Flow\Parquet\ThriftModel\OffsetIndex as ThriftOffsetIndex;
+use Thrift\Exception\TException;
+
+use function array_key_exists;
+
+/**
+ * Reads an index only when it is asked for, once. The footer is asked for each column's chunks on its own: the arrow
+ * engine's RowGroupChunks hold only the columns they were built for.
+ */
+final class StreamIndexes implements Indexes
+{
+    /**
+     * @var array<string, array<int, null|Sbbf>>
+     */
+    private array $bloomFilters = [];
+
+    /**
+     * @var array<string, RowGroupChunks>
+     */
+    private array $chunks = [];
+
+    /**
+     * @var array<string, array<int, null|ColumnIndex>>
+     */
+    private array $columnIndexes = [];
+
+    /**
+     * @var array<string, array<int, null|OffsetIndex>>
+     */
+    private array $offsetIndexes = [];
+
+    public function __construct(
+        private readonly Footer $footer,
+        private readonly SourceStream $stream,
+    ) {}
+
+    public function bloomFilter(int $rowGroup, FlatColumn $column): ?Sbbf
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($rowGroup, $this->bloomFilters[$path] ?? [])) {
+            try {
+                $this->bloomFilters[$path][$rowGroup] = (new BloomFilterReader($this->stream))->read($this->chunks(
+                    $column,
+                )->chunk($rowGroup, $column));
+            } catch (InvalidArgumentException|RuntimeException|TException) {
+                $this->bloomFilters[$path][$rowGroup] = null;
+            }
+        }
+
+        return $this->bloomFilters[$path][$rowGroup];
+    }
+
+    public function columnIndex(int $rowGroup, FlatColumn $column): ?ColumnIndex
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($rowGroup, $this->columnIndexes[$path] ?? [])) {
+            $thrift = new ThriftColumnIndex();
+
+            try {
+                $this->columnIndexes[$path][$rowGroup] = $this->read(
+                    $thrift,
+                    $this->chunks($column)->chunk($rowGroup, $column)->columnIndex(),
+                )
+                    ? ColumnIndex::fromThrift($thrift)
+                    : null;
+            } catch (InvalidArgumentException|TException) {
+                $this->columnIndexes[$path][$rowGroup] = null;
+            }
+        }
+
+        return $this->columnIndexes[$path][$rowGroup];
+    }
+
+    public function offsetIndex(int $rowGroup, FlatColumn $column): ?OffsetIndex
+    {
+        $path = $column->flatPath();
+
+        if (!array_key_exists($rowGroup, $this->offsetIndexes[$path] ?? [])) {
+            $chunks = $this->chunks($column);
+            $chunk = $chunks->chunk($rowGroup, $column);
+            $thrift = new ThriftOffsetIndex();
+
+            try {
+                $offsetIndex = $this->read($thrift, $chunk->offsetIndex()) ? OffsetIndex::fromThrift($thrift) : null;
+            } catch (TException) {
+                $offsetIndex = null;
+            }
+
+            $this->offsetIndexes[$path][$rowGroup] = $offsetIndex !== null
+            && $offsetIndex->fits($chunk, $chunks->rowCounts()[$rowGroup])
+                ? $offsetIndex
+                : null;
+        }
+
+        return $this->offsetIndexes[$path][$rowGroup];
+    }
+
+    /**
+     * Whether the chunk locates the index, which is then read into $thrift.
+     */
+    private function read(ThriftColumnIndex|ThriftOffsetIndex $thrift, ?IndexLocation $location): bool
+    {
+        if ($location === null) {
+            return false;
+        }
+
+        $thrift->read(new CompactProtocol(new MemoryBuffer($this->stream->read($location->length, $location->offset))));
+
+        return true;
+    }
+
+    private function chunks(FlatColumn $column): RowGroupChunks
+    {
+        return $this->chunks[$column->flatPath()] ??= $this->footer->rowGroupChunks([$column]);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Metadata.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Metadata.php
index b78a778e71..bf0a7bad3a 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Metadata.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Metadata.php
@@ -4,28 +4,58 @@
 
 namespace Flow\Parquet\ParquetFile;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ThriftModel\ColumnOrder as ThriftColumnOrder;
 use Flow\Parquet\ThriftModel\FileMetaData;
 
-final readonly class Metadata
+use function array_map;
+use function array_values;
+use function count;
+use function sprintf;
+
+final class Metadata
 {
+    /**
+     * @var null|array<string, ColumnOrder>
+     */
+    private ?array $columnOrdersByPath = null;
+
+    /**
+     * @param list<ColumnOrder> $columnOrders one per leaf in Schema::columnsFlat() order, empty when the footer has none
+     */
     public function __construct(
-        private Schema $schema,
-        private RowGroups $rowGroups,
-        private int $rowsNumber,
-        private int $version,
-        private ?string $createdBy,
+        private readonly Schema $schema,
+        private readonly RowGroups $rowGroups,
+        private readonly int $rowsNumber,
+        private readonly int $version,
+        private readonly ?string $createdBy,
+        private readonly array $columnOrders = [],
     ) {}
 
-    // called by name from arrow-ext RustParquetFileReader::metadata(), pinned by phpts 047, 052
+    // called by name from arrow-ext RustParquetFooter::metadata(), pinned by phpts 047, 052
     public static function fromThrift(FileMetaData $thrift): self
     {
+        $schema = Schema::fromThrift($thrift->schema);
+        $columnOrders = array_map(ColumnOrder::fromThrift(...), array_values($thrift->column_orders ?? []));
+        $leaves = count($schema->columnsFlat());
+
+        if ($columnOrders !== [] && count($columnOrders) !== $leaves) {
+            throw new InvalidArgumentException(sprintf(
+                'Footer holds %d column orders for %d leaf columns',
+                count($columnOrders),
+                $leaves,
+            ));
+        }
+
         return new self(
-            Schema::fromThrift($thrift->schema),
+            $schema,
             RowGroups::fromThrift($thrift->row_groups),
             (int) $thrift->num_rows,
             (int) $thrift->version,
             $thrift->created_by,
+            $columnOrders,
         );
     }
 
@@ -45,6 +75,27 @@ public function columnChunks(): array
         return $chunks;
     }
 
+    public function columnOrder(FlatColumn $column): ColumnOrder
+    {
+        if ($this->columnOrders === []) {
+            return ColumnOrder::Absent;
+        }
+
+        if ($this->columnOrdersByPath === null) {
+            $this->columnOrdersByPath = [];
+
+            foreach (array_values($this->schema->columnsFlat()) as $index => $leaf) {
+                $this->columnOrdersByPath[$leaf->flatPath()] = $this->columnOrders[$index];
+            }
+        }
+
+        return (
+            $this->columnOrdersByPath[$column->flatPath()] ?? throw new InvalidArgumentException(
+                'Column "' . $column->flatPath() . '" is not a leaf of the schema',
+            )
+        );
+    }
+
     public function createdBy(): ?string
     {
         return $this->createdBy;
@@ -73,6 +124,12 @@ public function toThrift(): FileMetaData
             'num_rows' => $this->rowGroups->rowsCount(),
             'row_groups' => $this->rowGroups->toThrift(),
             'created_by' => $this->createdBy,
+            'column_orders' => $this->columnOrders === []
+                ? null
+                : array_map(
+                    static fn(ColumnOrder $order): ThriftColumnOrder => $order->toThrift(),
+                    $this->columnOrders,
+                ),
         ]);
     }
 
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/MetadataRowGroupChunks.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/MetadataRowGroupChunks.php
new file mode 100644
index 0000000000..d6d4aa685f
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/MetadataRowGroupChunks.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile;
+
+use Flow\Parquet\Exception\OutOfBoundsException;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function array_key_exists;
+use function array_map;
+use function array_values;
+
+final readonly class MetadataRowGroupChunks implements RowGroupChunks
+{
+    /**
+     * @var list<int>
+     */
+    private array $rowCounts;
+
+    public function __construct(
+        private Metadata $metadata,
+    ) {
+        $this->rowCounts = array_values(array_map(
+            static fn(RowGroup $rowGroup): int => $rowGroup->rowsCount(),
+            $this->metadata->rowGroups()->all(),
+        ));
+    }
+
+    public function chunk(int $rowGroup, FlatColumn $column): ColumnChunk
+    {
+        return $this->rowGroup($rowGroup)->getColumnChunk($column);
+    }
+
+    public function columnOrder(FlatColumn $column): ColumnOrder
+    {
+        return $this->metadata->columnOrder($column);
+    }
+
+    public function rowCounts(): array
+    {
+        return $this->rowCounts;
+    }
+
+    private function rowGroup(int $rowGroup): RowGroup
+    {
+        $rowGroups = $this->metadata->rowGroups()->all();
+
+        if (!array_key_exists($rowGroup, $rowGroups)) {
+            throw new OutOfBoundsException('Row group ' . $rowGroup . ' does not exist');
+        }
+
+        return $rowGroups[$rowGroup];
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeader.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeader.php
index 5e7ebbae66..4170d93609 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeader.php
@@ -5,6 +5,8 @@
 namespace Flow\Parquet\ParquetFile\Page\Header;
 
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\RowGroup\StatisticsReader;
+use Flow\Parquet\ParquetFile\Statistics;
 use Flow\Parquet\ThriftModel\DataPageHeader as ThriftDataPageHeader;
 
 final readonly class DataPageHeader
@@ -14,6 +16,7 @@ public function __construct(
         private Encodings $repetitionLevelEncoding,
         private Encodings $definitionLevelEncoding,
         private int $valuesCount,
+        private ?Statistics $statistics = null,
     ) {}
 
     public static function fromThrift(ThriftDataPageHeader $thrift): self
@@ -23,6 +26,7 @@ public static function fromThrift(ThriftDataPageHeader $thrift): self
             Encodings::from($thrift->repetition_level_encoding),
             Encodings::from($thrift->definition_level_encoding),
             (int) $thrift->num_values,
+            $thrift->statistics !== null ? Statistics::fromThrift($thrift->statistics) : null,
         );
     }
 
@@ -41,6 +45,11 @@ public function repetitionLevelEncoding(): Encodings
         return $this->repetitionLevelEncoding;
     }
 
+    public function statistics(): ?StatisticsReader
+    {
+        return $this->statistics === null ? null : new StatisticsReader($this->statistics);
+    }
+
     public function toThrift(): ThriftDataPageHeader
     {
         return new ThriftDataPageHeader([
@@ -48,6 +57,7 @@ public function toThrift(): ThriftDataPageHeader
             'encoding' => $this->encoding->value,
             'definition_level_encoding' => $this->definitionLevelEncoding->value,
             'repetition_level_encoding' => $this->repetitionLevelEncoding->value,
+            'statistics' => $this->statistics?->toThrift(),
         ]);
     }
 
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeaderV2.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeaderV2.php
index 7edd940eed..b4d8dcbdf6 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeaderV2.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/Header/DataPageHeaderV2.php
@@ -33,8 +33,6 @@ public static function fromThrift(ThriftDataPageHeaderV2 $thrift, Options $optio
             (int) $thrift->definition_levels_byte_length,
             (int) $thrift->repetition_levels_byte_length,
             $thrift->is_compressed,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $thrift->statistics !== null ? Statistics::fromThrift($thrift->statistics) : null,
         );
     }
@@ -54,7 +52,7 @@ public function repetitionsByteLength(): int
         return $this->repetitionsByteLength;
     }
 
-    public function statistics(Options $options): ?StatisticsReader
+    public function statistics(): ?StatisticsReader
     {
         if ($this->statistics === null) {
             return null;
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/PageHeader.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/PageHeader.php
index 75c9669656..2b312480a0 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/PageHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Page/PageHeader.php
@@ -11,7 +11,13 @@
 use Flow\Parquet\ParquetFile\Page\Header\DataPageHeaderV2;
 use Flow\Parquet\ParquetFile\Page\Header\DictionaryPageHeader;
 use Flow\Parquet\ParquetFile\Page\Header\Type;
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\PhpFileStream;
 use Flow\Parquet\ThriftModel\PageHeader as ThriftPageHeader;
+use Throwable;
+
+use function fseek;
+use function ftell;
 
 final readonly class PageHeader
 {
@@ -24,22 +30,39 @@ public function __construct(
         private ?DictionaryPageHeader $dictionaryPageHeader,
     ) {}
 
+    /**
+     * The header at the stream's position, which is left after it; null, the position kept, when none is there.
+     *
+     * @param resource $stream
+     */
+    public static function read($stream, Options $options): ?self
+    {
+        $currentOffset = ftell($stream);
+
+        try {
+            $thriftHeader = new ThriftPageHeader();
+            @$thriftHeader->read(new CompactProtocol(new PhpFileStream($stream)));
+
+            return self::fromThrift($thriftHeader, $options);
+        } catch (Throwable) {
+            if ($currentOffset !== false) {
+                fseek($stream, $currentOffset);
+            }
+
+            return null;
+        }
+    }
+
     public static function fromThrift(ThriftPageHeader $thrift, Options $options): self
     {
         return new self(
             Type::from($thrift->type),
             (int) $thrift->compressed_page_size,
             (int) $thrift->uncompressed_page_size,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $thrift->data_page_header !== null ? DataPageHeader::fromThrift($thrift->data_page_header) : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $thrift->data_page_header_v2 !== null
                 ? DataPageHeaderV2::fromThrift($thrift->data_page_header_v2, $options)
                 : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $thrift->dictionary_page_header !== null
                 ? DictionaryPageHeader::fromThrift($thrift->dictionary_page_header)
                 : null,
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/BoundaryOrder.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/BoundaryOrder.php
new file mode 100644
index 0000000000..2339e929db
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/BoundaryOrder.php
@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\PageIndex;
+
+enum BoundaryOrder: int
+{
+    case ASCENDING = 1;
+    case DESCENDING = 2;
+    case UNORDERED = 0;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/ColumnIndex.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/ColumnIndex.php
new file mode 100644
index 0000000000..8ed1dec8b2
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/ColumnIndex.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\PageIndex;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ThriftModel\ColumnIndex as ThriftColumnIndex;
+
+use function array_map;
+use function array_values;
+use function count;
+
+/**
+ * Entry i describes page i of the chunk's offset index; minValues/maxValues are the statistic bytes, empty for a
+ * null page.
+ */
+final readonly class ColumnIndex
+{
+    /**
+     * @param list<bool> $nullPages
+     * @param list<string> $minValues
+     * @param list<string> $maxValues
+     * @param null|list<int> $nullCounts
+     * @param null|list<int> $nanCounts
+     */
+    public function __construct(
+        public array $nullPages,
+        public array $minValues,
+        public array $maxValues,
+        public BoundaryOrder $boundaryOrder,
+        public ?array $nullCounts = null,
+        public ?array $nanCounts = null,
+    ) {
+        $pages = count($nullPages);
+
+        if (
+            count($minValues) !== $pages
+            || count($maxValues) !== $pages
+            || $nullCounts !== null && count($nullCounts) !== $pages
+            || $nanCounts !== null && count($nanCounts) !== $pages
+        ) {
+            throw new InvalidArgumentException('Every list of a column index has one entry per page');
+        }
+    }
+
+    public static function fromThrift(ThriftColumnIndex $index): self
+    {
+        return new self(
+            array_values($index->null_pages ?? []),
+            array_values($index->min_values ?? []),
+            array_values($index->max_values ?? []),
+            BoundaryOrder::tryFrom((int) $index->boundary_order) ?? throw new InvalidArgumentException('Unknown column index boundary order '
+            . $index->boundary_order),
+            $index->null_counts === null
+                ? null
+                : array_values(array_map(static fn($count): int => (int) $count, $index->null_counts)),
+            $index->nan_counts === null
+                ? null
+                : array_values(array_map(static fn($count): int => (int) $count, $index->nan_counts)),
+        );
+    }
+
+    public function pages(): int
+    {
+        return count($this->nullPages);
+    }
+
+    public function toThrift(): ThriftColumnIndex
+    {
+        return new ThriftColumnIndex([
+            'null_pages' => $this->nullPages,
+            'min_values' => $this->minValues,
+            'max_values' => $this->maxValues,
+            'boundary_order' => $this->boundaryOrder->value,
+            'null_counts' => $this->nullCounts,
+            'nan_counts' => $this->nanCounts,
+        ]);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/OffsetIndex.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/OffsetIndex.php
new file mode 100644
index 0000000000..81564b4685
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/OffsetIndex.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\PageIndex;
+
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ThriftModel\OffsetIndex as ThriftOffsetIndex;
+use Flow\Parquet\ThriftModel\PageLocation as ThriftPageLocation;
+
+use function array_map;
+use function array_values;
+use function count;
+use function intdiv;
+
+final readonly class OffsetIndex
+{
+    /**
+     * @param list<PageLocation> $pages
+     */
+    public function __construct(
+        public array $pages,
+    ) {}
+
+    public static function fromThrift(ThriftOffsetIndex $index): self
+    {
+        return new self(array_values(array_map(
+            static fn(ThriftPageLocation $location): PageLocation => PageLocation::fromThrift($location),
+            $index->page_locations ?? [],
+        )));
+    }
+
+    /**
+     * Whether the pages lie inside the chunk, each after the previous and a byte at least, and split a row group of
+     * $rows rows: the first starts at row 0, each later one after the previous, all before the group's end.
+     */
+    public function fits(ColumnChunk $chunk, int $rows): bool
+    {
+        $previousRow = -1;
+        $previousEnd = $chunk->pageOffset();
+        $chunkEnd = $chunk->pageOffset() + $chunk->totalCompressedSize();
+
+        foreach ($this->pages as $page) {
+            $end = $page->offset + $page->compressedPageSize;
+
+            if (
+                $page->firstRowIndex <= $previousRow
+                || $page->firstRowIndex >= $rows
+                || $page->compressedPageSize < 1
+                || $page->offset < $previousEnd
+                || $end > $chunkEnd
+            ) {
+                return false;
+            }
+
+            $previousRow = $page->firstRowIndex;
+            $previousEnd = $end;
+        }
+
+        return $this->pages !== [] && $this->pages[0]->firstRowIndex === 0;
+    }
+
+    /**
+     * The page holding row $row of the row group.
+     */
+    public function pageOf(int $row): int
+    {
+        $low = 0;
+        $high = count($this->pages) - 1;
+
+        while ($low < $high) {
+            $middle = intdiv($low + $high + 1, 2);
+
+            if ($this->pages[$middle]->firstRowIndex <= $row) {
+                $low = $middle;
+            } else {
+                $high = $middle - 1;
+            }
+        }
+
+        return $low;
+    }
+
+    /**
+     * Rows of page $page, the last page ending at the row group's $rowGroupRows.
+     */
+    public function pageRows(int $page, int $rowGroupRows): int
+    {
+        $next = ($page + 1) < count($this->pages) ? $this->pages[$page + 1]->firstRowIndex : $rowGroupRows;
+
+        return $next - $this->pages[$page]->firstRowIndex;
+    }
+
+    public function toThrift(): ThriftOffsetIndex
+    {
+        return new ThriftOffsetIndex([
+            'page_locations' => array_map(
+                static fn(PageLocation $page): ThriftPageLocation => $page->toThrift(),
+                $this->pages,
+            ),
+        ]);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/PageIndex.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/PageIndex.php
new file mode 100644
index 0000000000..6efaa374c0
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/PageIndex.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\PageIndex;
+
+use function count;
+
+/**
+ * A column chunk's column index and offset index that agree with each other and with the row group.
+ */
+final readonly class PageIndex
+{
+    private function __construct(
+        public ColumnIndex $columnIndex,
+        public OffsetIndex $offsetIndex,
+        private int $rowGroupRows,
+    ) {}
+
+    /**
+     * Null without both indexes or when they disagree on the pages.
+     */
+    public static function of(?ColumnIndex $columnIndex, ?OffsetIndex $offsetIndex, int $rowGroupRows): ?self
+    {
+        if ($columnIndex === null || $offsetIndex === null || $columnIndex->pages() !== count($offsetIndex->pages)) {
+            return null;
+        }
+
+        return new self($columnIndex, $offsetIndex, $rowGroupRows);
+    }
+
+    /**
+     * The page holding row $row of the row group.
+     */
+    public function pageOf(int $row): int
+    {
+        return $this->offsetIndex->pageOf($row);
+    }
+
+    public function pageRows(int $page): int
+    {
+        return $this->offsetIndex->pageRows($page, $this->rowGroupRows);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/PageLocation.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/PageLocation.php
new file mode 100644
index 0000000000..dc0c80327f
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/PageIndex/PageLocation.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile\PageIndex;
+
+use Flow\Parquet\ThriftModel\PageLocation as ThriftPageLocation;
+
+/**
+ * $offset and $compressedPageSize include the page header; $firstRowIndex is relative to the row group.
+ */
+final readonly class PageLocation
+{
+    public function __construct(
+        public int $offset,
+        public int $compressedPageSize,
+        public int $firstRowIndex,
+    ) {}
+
+    public static function fromThrift(ThriftPageLocation $location): self
+    {
+        return new self(
+            (int) $location->offset,
+            (int) $location->compressed_page_size,
+            (int) $location->first_row_index,
+        );
+    }
+
+    public function toThrift(): ThriftPageLocation
+    {
+        return new ThriftPageLocation([
+            'offset' => $this->offset,
+            'compressed_page_size' => $this->compressedPageSize,
+            'first_row_index' => $this->firstRowIndex,
+        ]);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/ColumnChunk.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/ColumnChunk.php
index b7499326a0..25f668fb12 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/ColumnChunk.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/ColumnChunk.php
@@ -4,9 +4,11 @@
 
 namespace Flow\Parquet\ParquetFile\RowGroup;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\Index\IndexLocation;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\ParquetFile\Statistics;
 use Flow\Parquet\ThriftModel\ColumnChunk as ThriftColumnChunk;
@@ -29,7 +31,7 @@
      * @param int $totalCompressedSize
      * @param int $totalUncompressedSize
      * @param null|int $dictionaryPageOffset
-     * @param null|int $dataPageOffset
+     * @param int $dataPageOffset
      * @param null|int $indexPageOffset
      */
     public function __construct(
@@ -42,45 +44,76 @@ public function __construct(
         private int $totalCompressedSize,
         private int $totalUncompressedSize,
         private ?int $dictionaryPageOffset,
-        private ?int $dataPageOffset,
+        private int $dataPageOffset,
         private ?int $indexPageOffset,
         private ?Statistics $statistics,
-    ) {}
+        private ?IndexLocation $columnIndex = null,
+        private ?IndexLocation $offsetIndex = null,
+        private ?int $bloomFilterOffset = null,
+        private ?int $bloomFilterLength = null,
+    ) {
+        if ($bloomFilterLength !== null && $bloomFilterOffset === null) {
+            throw new InvalidArgumentException('A column chunk records a bloom filter length without its offset');
+        }
+    }
 
     public static function fromThrift(ThriftColumnChunk $thrift): self
     {
+        $metadata = $thrift->meta_data ?? throw new InvalidArgumentException(
+            'Column chunk at offset '
+            . $thrift->file_offset
+            . ' has no metadata (an encrypted column is not supported)',
+        );
+
         return new self(
-            PhysicalType::from($thrift->meta_data->type),
-            Compressions::from($thrift->meta_data->codec),
-            (int) $thrift->meta_data->num_values,
+            PhysicalType::from($metadata->type),
+            Compressions::from($metadata->codec),
+            (int) $metadata->num_values,
             (int) $thrift->file_offset,
-            $thrift->meta_data->path_in_schema,
-            array_map(static fn($encoding) => Encodings::from($encoding), $thrift->meta_data->encodings),
-            (int) $thrift->meta_data->total_compressed_size,
-            (int) $thrift->meta_data->total_uncompressed_size,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
-            $thrift->meta_data->dictionary_page_offset !== null
-                ? (int) $thrift->meta_data->dictionary_page_offset
+            $metadata->path_in_schema,
+            array_map(static fn($encoding) => Encodings::from($encoding), $metadata->encodings),
+            (int) $metadata->total_compressed_size,
+            (int) $metadata->total_uncompressed_size,
+            $metadata->dictionary_page_offset !== null ? (int) $metadata->dictionary_page_offset : null,
+            (int) $metadata->data_page_offset,
+            $metadata->index_page_offset !== null ? (int) $metadata->index_page_offset : null,
+            $metadata->statistics !== null ? Statistics::fromThrift($metadata->statistics) : null,
+            IndexLocation::fromThrift($thrift->column_index_offset, $thrift->column_index_length),
+            IndexLocation::fromThrift($thrift->offset_index_offset, $thrift->offset_index_length),
+            $metadata->bloom_filter_offset !== null ? (int) $metadata->bloom_filter_offset : null,
+            $metadata->bloom_filter_offset !== null && $metadata->bloom_filter_length !== null
+                ? (int) $metadata->bloom_filter_length
                 : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
-            $thrift->meta_data->data_page_offset !== null ? (int) $thrift->meta_data->data_page_offset : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
-            $thrift->meta_data->index_page_offset !== null ? (int) $thrift->meta_data->index_page_offset : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
-            $thrift->meta_data->statistics !== null ? Statistics::fromThrift($thrift->meta_data->statistics) : null,
         );
     }
 
+    /**
+     * Null when the writer did not record it: the header is then read before the bitset.
+     */
+    public function bloomFilterLength(): ?int
+    {
+        return $this->bloomFilterLength;
+    }
+
+    /**
+     * Null when the chunk has no bloom filter.
+     */
+    public function bloomFilterOffset(): ?int
+    {
+        return $this->bloomFilterOffset;
+    }
+
     public function codec(): Compressions
     {
         return $this->codec;
     }
 
-    public function dataPageOffset(): ?int
+    public function columnIndex(): ?IndexLocation
+    {
+        return $this->columnIndex;
+    }
+
+    public function dataPageOffset(): int
     {
         return $this->dataPageOffset;
     }
@@ -108,6 +141,11 @@ public function flatPath(): string
         return implode('.', $this->path);
     }
 
+    public function offsetIndex(): ?IndexLocation
+    {
+        return $this->offsetIndex;
+    }
+
     public function pageOffset(): int
     {
         $offsets = array_filter(
@@ -161,7 +199,13 @@ public function toThrift(): ThriftColumnChunk
                 'index_page_offset' => $this->indexPageOffset,
                 'dictionary_page_offset' => $this->dictionaryPageOffset,
                 'statistics' => $this->statistics?->toThrift(),
+                'bloom_filter_offset' => $this->bloomFilterOffset,
+                'bloom_filter_length' => $this->bloomFilterLength,
             ]),
+            'column_index_offset' => $this->columnIndex?->offset,
+            'column_index_length' => $this->columnIndex?->length,
+            'offset_index_offset' => $this->offsetIndex?->offset,
+            'offset_index_length' => $this->offsetIndex?->length,
         ]);
     }
 
@@ -170,6 +214,36 @@ public function type(): PhysicalType
         return $this->type;
     }
 
+    /**
+     * This chunk with its page index and its bloom filter (header and bitset) written at the given locations; a
+     * location left out is kept.
+     */
+    public function withLocations(
+        ?IndexLocation $columnIndex = null,
+        ?IndexLocation $offsetIndex = null,
+        ?int $bloomFilterOffset = null,
+        ?int $bloomFilterLength = null,
+    ): self {
+        return new self(
+            $this->type,
+            $this->codec,
+            $this->valuesCount,
+            $this->fileOffset,
+            $this->path,
+            $this->encodings,
+            $this->totalCompressedSize,
+            $this->totalUncompressedSize,
+            $this->dictionaryPageOffset,
+            $this->dataPageOffset,
+            $this->indexPageOffset,
+            $this->statistics,
+            $columnIndex ?? $this->columnIndex,
+            $offsetIndex ?? $this->offsetIndex,
+            $bloomFilterOffset ?? $this->bloomFilterOffset,
+            $bloomFilterLength ?? $this->bloomFilterLength,
+        );
+    }
+
     public function valuesCount(): int
     {
         return $this->valuesCount;
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/StatisticsReader.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/StatisticsReader.php
index bed3dfdbf1..b6eb7dd2b8 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/StatisticsReader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroup/StatisticsReader.php
@@ -4,23 +4,18 @@
 
 namespace Flow\Parquet\ParquetFile\RowGroup;
 
-use Flow\Parquet\Binary\ByteOrder;
-use Flow\Parquet\BinaryReader\BinaryBufferReader;
-use Flow\Parquet\Data\PlainValueUnpacker;
-use Flow\Parquet\ParquetFile\Schema\ColumnPrimitiveType;
+use Flow\Parquet\Data\PhysicalCodec;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Statistics;
 
-use function iterator_to_array;
-
 final readonly class StatisticsReader
 {
-    private ByteOrder $byteOrder;
+    private PhysicalCodec $codec;
 
     public function __construct(
         private Statistics $statistics,
     ) {
-        $this->byteOrder = ByteOrder::LITTLE_ENDIAN;
+        $this->codec = new PhysicalCodec();
     }
 
     public function distinctCount(): ?int
@@ -28,80 +23,48 @@ public function distinctCount(): ?int
         return $this->statistics->distinctCount;
     }
 
-    public function max(FlatColumn $column): mixed
+    public function isMaxValueExact(): ?bool
     {
-        $max = $this->statistics->max;
-
-        if ($max === null) {
-            return null;
-        }
-
-        if (ColumnPrimitiveType::isString($column)) {
-            return $max;
-        }
-
-        return iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($max), $this->byteOrder))->unpack(
-            $column,
-            1,
-        ))[0];
+        return $this->statistics->isMaxValueExact;
     }
 
-    public function maxValue(FlatColumn $column): mixed
+    public function isMinValueExact(): ?bool
     {
-        $maxValue = $this->statistics->maxValue;
-
-        if ($maxValue === null) {
-            return null;
-        }
-
-        if (ColumnPrimitiveType::isString($column)) {
-            return $maxValue;
-        }
-
-        return iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($maxValue), $this->byteOrder))->unpack(
-            $column,
-            1,
-        ))[0];
+        return $this->statistics->isMinValueExact;
     }
 
-    public function min(FlatColumn $column): mixed
+    public function max(FlatColumn $column): bool|float|int|string|null
     {
-        $min = $this->statistics->min;
-
-        if ($min === null) {
-            return null;
-        }
-
-        if (ColumnPrimitiveType::isString($column)) {
-            return $min;
-        }
-
-        return iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($min), $this->byteOrder))->unpack(
-            $column,
-            1,
-        ))[0];
+        return $this->decode($column, $this->statistics->max);
     }
 
-    public function minValue(FlatColumn $column): mixed
+    public function maxValue(FlatColumn $column): bool|float|int|string|null
     {
-        $minValue = $this->statistics->minValue;
+        return $this->decode($column, $this->statistics->maxValue);
+    }
 
-        if ($minValue === null) {
-            return null;
-        }
+    public function min(FlatColumn $column): bool|float|int|string|null
+    {
+        return $this->decode($column, $this->statistics->min);
+    }
 
-        if (ColumnPrimitiveType::isString($column)) {
-            return $minValue;
-        }
+    public function minValue(FlatColumn $column): bool|float|int|string|null
+    {
+        return $this->decode($column, $this->statistics->minValue);
+    }
 
-        return iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($minValue), $this->byteOrder))->unpack(
-            $column,
-            1,
-        ))[0];
+    public function nanCount(): ?int
+    {
+        return $this->statistics->nanCount;
     }
 
     public function nullCount(): ?int
     {
         return $this->statistics->nullCount;
     }
+
+    private function decode(FlatColumn $column, ?string $bytes): bool|float|int|string|null
+    {
+        return $bytes === null ? null : $this->codec->decodeStatistic($column, $bytes);
+    }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroupChunks.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroupChunks.php
new file mode 100644
index 0000000000..44f72d0aea
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/RowGroupChunks.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\ParquetFile;
+
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+interface RowGroupChunks
+{
+    public function chunk(int $rowGroup, FlatColumn $column): ColumnChunk;
+
+    public function columnOrder(FlatColumn $column): ColumnOrder;
+
+    /**
+     * Every row group's row count, in file order.
+     *
+     * @return list<int>
+     */
+    public function rowCounts(): array;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema.php
index 548e4cb0e6..39964ede9d 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema.php
@@ -25,7 +25,7 @@ public function __construct(
         private readonly NestedColumn $schemaRoot,
     ) {}
 
-    // called by name from arrow-ext RustParquetFileReader::schema(), pinned by phpts 047, 052
+    // called by name from arrow-ext RustParquetFooter::schema(), pinned by phpts 047, 052
     /**
      * @param array<SchemaElement> $schemaElements
      */
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/FlatColumn.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/FlatColumn.php
index bda56927d8..92be913903 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/FlatColumn.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/FlatColumn.php
@@ -15,6 +15,7 @@
 use function floor;
 use function implode;
 use function log10;
+use function sprintf;
 
 final class FlatColumn implements Column
 {
@@ -39,7 +40,16 @@ public function __construct(
         private readonly ?int $precision = null,
         private readonly ?int $scale = null,
         private readonly ?int $typeLength = null,
-    ) {}
+    ) {
+        if ($convertedType !== null && $logicalType !== null && $logicalType->convertedType() !== $convertedType) {
+            throw new InvalidArgumentException(sprintf(
+                'Column "%s": converted type %s contradicts logical type %s',
+                $name,
+                $convertedType->name,
+                $logicalType->name(),
+            ));
+        }
+    }
 
     public static function boolean(string $name, Repetition $repetition = Repetition::OPTIONAL): self
     {
@@ -84,6 +94,19 @@ public static function decimal(
             throw new InvalidArgumentException('Precision must be between 1 and 38, ' . $precision . ' given.');
         }
 
+        // arrow-rs, parquet-mr and DuckDB: INT32 up to precision 9, INT64 up to 18, FIXED_LEN_BYTE_ARRAY above
+        if ($precision <= 18) {
+            return new self(
+                $name,
+                $precision <= 9 ? PhysicalType::INT32 : PhysicalType::INT64,
+                ConvertedType::DECIMAL,
+                LogicalType::decimal($scale, $precision),
+                $repetition,
+                $precision,
+                $scale,
+            );
+        }
+
         // Parquet LogicalTypes.md, DECIMAL
         $byteLength = 1;
 
@@ -132,41 +155,31 @@ public static function float(string $name, Repetition $repetition = Repetition::
 
     public static function fromThrift(SchemaElement $thrift): self
     {
-        // @mago-ignore analysis:redundant-comparison
-        // @mago-ignore analysis:impossible-condition
         $convertedType = $thrift->converted_type === null ? null : ConvertedType::from($thrift->converted_type);
-        // @mago-ignore analysis:redundant-comparison
-        // @mago-ignore analysis:redundant-condition
         $precision = $thrift->precision !== null ? (int) $thrift->precision : null;
-        // @mago-ignore analysis:redundant-comparison
-        // @mago-ignore analysis:redundant-condition
         $scale = $thrift->scale !== null ? (int) $thrift->scale : null;
-        // @mago-ignore analysis:redundant-comparison
-        // @mago-ignore analysis:impossible-condition
         $logicalType = $thrift->logicalType === null ? null : LogicalType::fromThrift($thrift->logicalType);
 
         return new self(
             $thrift->name,
-            PhysicalType::from($thrift->type),
+            PhysicalType::from(
+                $thrift->type ?? throw new InvalidArgumentException(
+                    'Schema element "' . $thrift->name . '" is a leaf without a physical type',
+                ),
+            ),
             $convertedType,
             $logicalType
-            // @mago-ignore analysis:redundant-comparison
-            // @mago-ignore analysis:impossible-condition
             ?? ($convertedType === null ? null : LogicalType::fromConvertedType($convertedType, $scale, $precision)),
-            // @mago-ignore analysis:redundant-comparison
-            // @mago-ignore analysis:impossible-condition
             $thrift->repetition_type === null ? null : Repetition::from($thrift->repetition_type),
             $precision,
             $scale,
-            // @mago-ignore analysis:redundant-comparison
-            // @mago-ignore analysis:redundant-condition
             $thrift->type_length !== null ? (int) $thrift->type_length : null,
         );
     }
 
     public static function int32(string $name, Repetition $repetition = Repetition::OPTIONAL): self
     {
-        return new self($name, PhysicalType::INT32, ConvertedType::INT_32, null, $repetition);
+        return new self($name, PhysicalType::INT32, null, null, $repetition);
     }
 
     public static function int64(string $name, Repetition $repetition = Repetition::OPTIONAL): self
@@ -179,7 +192,7 @@ public static function int64(string $name, Repetition $repetition = Repetition::
             );
         }
 
-        return new self($name, PhysicalType::INT64, ConvertedType::INT_64, null, $repetition);
+        return new self($name, PhysicalType::INT64, null, null, $repetition);
     }
 
     public static function json(string $string, Repetition $repetition = Repetition::OPTIONAL): self
@@ -246,7 +259,7 @@ public function convertedType(): ?ConvertedType
     }
 
     /**
-     * @return array<array-key, mixed>
+     * @return array{type: string, optional: bool}
      */
     public function ddl(): array
     {
@@ -440,7 +453,7 @@ public function toThrift(): SchemaElement
         return new SchemaElement([
             'name' => $this->name,
             'type' => $this->type->value,
-            'converted_type' => $this->convertedType?->value,
+            'converted_type' => ($this->convertedType ?? $this->logicalType?->convertedType())?->value,
             'repetition_type' => $this->repetition?->value,
             'logicalType' => $this->logicalType?->toThrift(),
             'precision' => $this->precision,
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType.php
index c4c5f4483e..b5710efb90 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType.php
@@ -85,6 +85,46 @@ public static function enum(): self
         return new self(self::ENUM);
     }
 
+    /**
+     * The converted type a writer annotates this logical type with for older readers (arrow-rs 60
+     * `ConvertedType::from(Option<LogicalType>)`); null where none exists.
+     */
+    public function convertedType(): ?ConvertedType
+    {
+        return match ($this->name) {
+            self::STRING => ConvertedType::UTF8,
+            self::MAP => ConvertedType::MAP,
+            self::LIST => ConvertedType::LIST,
+            self::ENUM => ConvertedType::ENUM,
+            self::DECIMAL => ConvertedType::DECIMAL,
+            self::DATE => ConvertedType::DATE,
+            self::TIME => match ($this->time?->unit()) {
+                TimeUnit::MILLISECONDS => ConvertedType::TIME_MILLIS,
+                TimeUnit::MICROSECONDS => ConvertedType::TIME_MICROS,
+                default => null,
+            },
+            self::TIMESTAMP => match ($this->timestamp?->unit()) {
+                TimeUnit::MILLISECONDS => ConvertedType::TIMESTAMP_MILLIS,
+                TimeUnit::MICROSECONDS => ConvertedType::TIMESTAMP_MICROS,
+                default => null,
+            },
+            self::INTEGER => match ([$this->integer?->bitWidth(), $this->integer?->isSigned()]) {
+                [8, true] => ConvertedType::INT_8,
+                [16, true] => ConvertedType::INT_16,
+                [32, true] => ConvertedType::INT_32,
+                [64, true] => ConvertedType::INT_64,
+                [8, false] => ConvertedType::UINT_8,
+                [16, false] => ConvertedType::UINT_16,
+                [32, false] => ConvertedType::UINT_32,
+                [64, false] => ConvertedType::UINT_64,
+                default => null,
+            },
+            self::JSON => ConvertedType::JSON,
+            self::BSON => ConvertedType::BSON,
+            default => null,
+        };
+    }
+
     public static function fromConvertedType(ConvertedType $convertedType, ?int $scale, ?int $precision): ?self
     {
         return match ($convertedType) {
@@ -108,109 +148,71 @@ public static function fromThrift(ThriftLogicalType $logicalType): ?self
     {
         $name = null;
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->STRING !== null) {
             $name = self::STRING;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->MAP !== null) {
             $name = self::MAP;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->LIST !== null) {
             $name = self::LIST;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->ENUM !== null) {
             $name = self::ENUM;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->DECIMAL !== null) {
             $name = self::DECIMAL;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->DATE !== null) {
             $name = self::DATE;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->TIME !== null) {
             $name = self::TIME;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->TIMESTAMP !== null) {
             $name = self::TIMESTAMP;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->INTEGER !== null) {
             $name = self::INTEGER;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->UNKNOWN !== null) {
             $name = self::UNKNOWN;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->JSON !== null) {
             $name = self::JSON;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->BSON !== null) {
             $name = self::BSON;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->UUID !== null) {
             $name = self::UUID;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($logicalType->FLOAT16 !== null) {
             $name = self::FLOAT16;
         }
 
-        // @mago-ignore analysis:impossible-condition
-        // @mago-ignore analysis:redundant-comparison
         if (null === $name) {
             return null;
         }
 
         return new self(
             $name,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             timestamp: $logicalType->TIMESTAMP !== null ? Timestamp::fromThrift($logicalType->TIMESTAMP) : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             time: $logicalType->TIME !== null ? Time::fromThrift($logicalType->TIME) : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             decimal: $logicalType->DECIMAL !== null ? Decimal::fromThrift($logicalType->DECIMAL) : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             integer: $logicalType->INTEGER !== null ? Integer::fromThrift($logicalType->INTEGER) : null,
         );
     }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType/Integer.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType/Integer.php
index 78d50df519..38ef921541 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType/Integer.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/LogicalType/Integer.php
@@ -43,6 +43,11 @@ public function bitWidth(): int
         return $this->bitWidth;
     }
 
+    public function is(int $bitWidth, bool $signed): bool
+    {
+        return $this->bitWidth === $bitWidth && $this->isSigned === $signed;
+    }
+
     public function isSigned(): bool
     {
         return $this->isSigned;
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/NestedColumn.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/NestedColumn.php
index 87354058ae..ad93c21d5f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/NestedColumn.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/NestedColumn.php
@@ -68,15 +68,9 @@ public static function fromThrift(SchemaElement $schemaElement, array $children)
     {
         return new self(
             $schemaElement->name,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $schemaElement->repetition_type !== null ? Repetition::from($schemaElement->repetition_type) : null,
             $children,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $schemaElement->converted_type !== null ? ConvertedType::from($schemaElement->converted_type) : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $schemaElement->logicalType !== null ? LogicalType::fromThrift($schemaElement->logicalType) : null,
         );
     }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/TimeUnit.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/TimeUnit.php
index fd3632d120..ce8d72677b 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/TimeUnit.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Schema/TimeUnit.php
@@ -15,20 +15,14 @@ enum TimeUnit: string
 
     public static function fromThrift(ThriftTimeUnit $unit): self
     {
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($unit->MILLIS !== null) {
             return self::MILLISECONDS;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($unit->MICROS !== null) {
             return self::MICROSECONDS;
         }
 
-        // @mago-ignore analysis:redundant-condition
-        // @mago-ignore analysis:redundant-comparison
         if ($unit->NANOS !== null) {
             return self::NANOSECONDS;
         }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Statistics.php b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Statistics.php
index 0557783769..9b44312d8a 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFile/Statistics.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFile/Statistics.php
@@ -17,6 +17,7 @@ public function __construct(
         public ?string $minValue,
         public ?bool $isMaxValueExact = null,
         public ?bool $isMinValueExact = null,
+        public ?int $nanCount = null,
     ) {}
 
     public static function fromThrift(ThriftStatistics $thrift): self
@@ -24,16 +25,13 @@ public static function fromThrift(ThriftStatistics $thrift): self
         return new self(
             $thrift->max,
             $thrift->min,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $thrift->null_count !== null ? (int) $thrift->null_count : null,
-            // @mago-ignore analysis:redundant-condition
-            // @mago-ignore analysis:redundant-comparison
             $thrift->distinct_count !== null ? (int) $thrift->distinct_count : null,
             $thrift->max_value,
             $thrift->min_value,
             $thrift->is_max_value_exact,
             $thrift->is_min_value_exact,
+            $thrift->nan_count,
         );
     }
 
@@ -48,6 +46,7 @@ public function toThrift(): ThriftStatistics
             'min_value' => $this->minValue,
             'is_max_value_exact' => $this->isMaxValueExact,
             'is_min_value_exact' => $this->isMinValueExact,
+            'nan_count' => $this->nanCount,
         ]);
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ParquetFileReader.php b/src/lib/parquet/src/Flow/Parquet/ParquetFileReader.php
index b98d703d9b..924a04eac0 100644
--- a/src/lib/parquet/src/Flow/Parquet/ParquetFileReader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ParquetFileReader.php
@@ -4,8 +4,8 @@
 
 namespace Flow\Parquet;
 
-use Flow\Parquet\ParquetFile\Metadata;
-use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Footer;
+use Flow\Parquet\Reader\ReadPlan;
 use Iterator;
 
 use function interface_exists;
@@ -22,27 +22,16 @@ interface ParquetFileReader
     public function close(): void;
 
     /**
-     * The whole footer as Metadata, built on the first call.
+     * The file's footer, read on the first call; it stays readable after close().
      */
-    public function metadata(): Metadata;
+    public function footer(): Footer;
 
     /**
      * @param list<string> $columns resolved names, never empty
-     * @param int<1, max> $batchSize upper bound of rows per chunk
+     * @param int $batchSize upper bound of rows per chunk, refused below 1
      *
-     * @return Iterator<int, array<string, list<mixed>>> chunks keyed by column, every list the same length (>0)
+     * @return Iterator<int, array<string, list<mixed>>> chunks keyed by column, every list the same length (>0): the rows
+     *         $plan selects that match $plan->rowFilter, at most $plan->limit
      */
-    public function readColumns(array $columns, int $batchSize, ?int $limit, ?int $offset): Iterator;
-
-    public function rowsNumber(): int;
-
-    /**
-     * The file schema, without building the row-group metadata.
-     */
-    public function schema(): Schema;
-
-    /**
-     * Σ row group total_byte_size (uncompressed), without building the row-group metadata.
-     */
-    public function totalByteSize(): int;
+    public function readColumns(array $columns, int $batchSize, ReadPlan $plan): Iterator;
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Query.php b/src/lib/parquet/src/Flow/Parquet/Query.php
new file mode 100644
index 0000000000..5ec51d5f62
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Query.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Filter;
+
+use function array_unique;
+use function array_values;
+use function count;
+
+/**
+ * The rows a read returns: the selected columns (all root columns when none) of the rows matching the filter, the
+ * offset and the limit counted over the matching rows.
+ */
+final readonly class Query
+{
+    /**
+     * @var list<string>
+     */
+    public array $columns;
+
+    /**
+     * @param array<string> $columns
+     */
+    public function __construct(
+        array $columns = [],
+        public ?Filter $filter = null,
+        public int $offset = 0,
+        public ?int $limit = null,
+    ) {
+        foreach ($columns as $column) {
+            if ($column === '') {
+                throw new InvalidArgumentException('A query column name cannot be empty');
+            }
+        }
+
+        if (count(array_unique($columns)) !== count($columns)) {
+            throw new InvalidArgumentException('A query selects each column once');
+        }
+
+        if ($offset < 0) {
+            throw new InvalidArgumentException('Query offset must be 0 or more, got ' . $offset);
+        }
+
+        if ($limit !== null && $limit < 0) {
+            throw new InvalidArgumentException('Query limit must be 0 or more, got ' . $limit);
+        }
+
+        $this->columns = array_values($columns);
+    }
+
+    public function limit(int $limit): self
+    {
+        return new self($this->columns, $this->filter, $this->offset, $limit);
+    }
+
+    public function offset(int $offset): self
+    {
+        return new self($this->columns, $this->filter, $offset, $this->limit);
+    }
+
+    public function select(string ...$columns): self
+    {
+        if ($columns === []) {
+            throw new InvalidArgumentException('A query selects at least one column');
+        }
+
+        return new self(array_values($columns), $this->filter, $this->offset, $this->limit);
+    }
+
+    /**
+     * A second filter narrows the first: both must match.
+     */
+    public function where(Filter $filter): self
+    {
+        return new self(
+            $this->columns,
+            $this->filter === null ? $filter : new All($this->filter, $filter),
+            $this->offset,
+            $this->limit,
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkReader.php b/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkReader.php
index ca06d5ce23..738dae889c 100644
--- a/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkReader.php
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkReader.php
@@ -8,16 +8,18 @@
 use Flow\Parquet\Dremel\ColumnData\ReadFlatColumnValues;
 use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Page\Dictionary;
 use Flow\Parquet\ParquetFile\Page\PageHeader;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
 use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
-use Flow\Parquet\Thrift\CompactProtocol;
-use Flow\Parquet\Thrift\PhpFileStream;
-use Flow\Parquet\ThriftModel\PageHeader as ThriftPageHeader;
 use Generator;
-use Throwable;
 
+use function array_key_last;
+use function array_map;
 use function fclose;
+use function fopen;
 use function fseek;
 use function ftell;
 use function fwrite;
@@ -33,9 +35,104 @@ public function __construct(
     ) {}
 
     /**
-     * @return \Generator<ReadFlatColumnValues>
+     * The chunk's data pages keyed by the row of the row group each starts at: the $pages of $offsetIndex, one
+     * SourceStream::read per run of adjacent pages, or every page without an offset index. The dictionary is read from
+     * the chunk's start up to the first indexed page, wherever `dictionary_page_offset` points (PARQUET-816), unless
+     * $dictionary is given. Returns the dictionary the pages were decoded with.
+     *
+     * @param list<int> $pages ascending positions in $offsetIndex
+     *
+     * @return Generator<int, ReadFlatColumnValues, mixed, ?Dictionary>
      */
-    public function read(ColumnChunk $columnChunk, FlatColumn $column, SourceStream $stream): Generator
+    public function read(
+        ColumnChunk $columnChunk,
+        FlatColumn $column,
+        SourceStream $stream,
+        ?OffsetIndex $offsetIndex = null,
+        array $pages = [],
+        ?Dictionary $dictionary = null,
+    ): Generator {
+        if ($offsetIndex === null) {
+            return yield from $this->readChunk($columnChunk, $column, $stream);
+        }
+
+        if ($pages === []) {
+            return $dictionary;
+        }
+
+        $firstPage = $offsetIndex->pages[0]->offset;
+        $leadingRegion = $dictionary === null && $columnChunk->pageOffset() < $firstPage;
+        $runs = $leadingRegion ? [new PageRun($columnChunk->pageOffset(), $firstPage)] : [];
+        $locations = array_map(static fn(int $page): PageLocation => $offsetIndex->pages[$page], $pages);
+
+        foreach ($locations as $page) {
+            $end = $page->offset + $page->compressedPageSize;
+            $last = array_key_last($runs);
+
+            if ($last !== null && $runs[$last]->end === $page->offset) {
+                $runs[$last] = $runs[$last]->extendedTo($end);
+            } else {
+                $runs[] = new PageRun($page->offset, $end);
+            }
+        }
+
+        $pageStream = fopen('php://temp', 'rb+');
+
+        if ($pageStream === false) {
+            throw new RuntimeException('Cannot open temporary stream');
+        }
+
+        $buffered = [];
+        $read = 0;
+
+        foreach ($runs as $pageRun) {
+            $buffered[] = $read;
+            $read += (int) fwrite($pageStream, $stream->read($pageRun->length, $pageRun->start));
+        }
+
+        if ($leadingRegion) {
+            rewind($pageStream);
+            $header = PageHeader::read($pageStream, $this->options);
+
+            if ($header !== null && $header->type()->isDictionaryPage()) {
+                $dictionary = $this->pageReader->readDictionary($column, $header, $columnChunk->codec(), $pageStream);
+            }
+        }
+
+        $run = 0;
+
+        foreach ($locations as $page) {
+            while ($runs[$run]->end <= $page->offset) {
+                $run++;
+            }
+
+            fseek($pageStream, $buffered[$run] + $page->offset - $runs[$run]->start);
+            $header = PageHeader::read($pageStream, $this->options);
+
+            if ($header === null || !$header->type()->isDataPage()) {
+                throw new RuntimeException(
+                    'No data page header at offset ' . $page->offset . ' the offset index locates',
+                );
+            }
+
+            yield $page->firstRowIndex => $this->pageReader->readData(
+                $column,
+                $header,
+                $columnChunk->codec(),
+                $dictionary,
+                $pageStream,
+            );
+        }
+
+        fclose($pageStream);
+
+        return $dictionary;
+    }
+
+    /**
+     * @return Generator<int, ReadFlatColumnValues, mixed, ?Dictionary>
+     */
+    private function readChunk(ColumnChunk $columnChunk, FlatColumn $column, SourceStream $stream): Generator
     {
         $pageStream = fopen('php://temp', 'rb+');
 
@@ -52,7 +149,7 @@ public function read(ColumnChunk $columnChunk, FlatColumn $column, SourceStream
         fwrite($pageStream, $stream->read($compressedSize, $columnChunk->pageOffset()));
         rewind($pageStream);
 
-        $header = $this->readHeader($pageStream);
+        $header = PageHeader::read($pageStream, $this->options);
 
         if ($header === null) {
             throw new RuntimeException('Cannot read first page header');
@@ -83,7 +180,7 @@ public function read(ColumnChunk $columnChunk, FlatColumn $column, SourceStream
         $yieldedRows = 0;
 
         while (true) {
-            $dataHeader = $dictionary ? $this->readHeader($pageStream) : $header;
+            $dataHeader = $dictionary ? PageHeader::read($pageStream, $this->options) : $header;
 
             if ($dataHeader === null || $dataHeader->type()->isDataPage() === false) {
                 break;
@@ -95,36 +192,17 @@ public function read(ColumnChunk $columnChunk, FlatColumn $column, SourceStream
 
             $data = $this->pageReader->readData($column, $dataHeader, $columnChunk->codec(), $dictionary, $pageStream);
 
-            $yieldedRows += $data->rowsCount();
+            yield $yieldedRows => $data;
 
-            yield $data;
+            $yieldedRows += $data->rowsCount();
 
             if ($dictionary === null) {
-                $header = $this->readHeader($pageStream);
+                $header = PageHeader::read($pageStream, $this->options);
             }
         }
 
         fclose($pageStream);
-    }
 
-    /**
-     * @param resource $stream
-     */
-    private function readHeader($stream): ?PageHeader
-    {
-        $currentOffset = ftell($stream);
-
-        try {
-            $thriftHeader = new ThriftPageHeader();
-            @$thriftHeader->read(new CompactProtocol(new PhpFileStream($stream)));
-
-            return PageHeader::fromThrift($thriftHeader, $this->options);
-        } catch (Throwable) {
-            if ($currentOffset !== false) {
-                fseek($stream, $currentOffset);
-            }
-
-            return null;
-        }
+        return $dictionary;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkViewer.php b/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkViewer.php
index abe4d4aa6a..62a45e6326 100644
--- a/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkViewer.php
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/ColumnChunkViewer.php
@@ -9,11 +9,7 @@
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Page\PageHeader;
 use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
-use Flow\Parquet\Thrift\CompactProtocol;
-use Flow\Parquet\Thrift\PhpFileStream;
-use Flow\Parquet\ThriftModel\PageHeader as ThriftPageHeader;
 use Generator;
-use Throwable;
 
 use function fclose;
 use function fseek;
@@ -48,7 +44,7 @@ public function view(ColumnChunk $columnChunk, SourceStream $stream): Generator
         rewind($pageStream);
 
         if ($columnChunk->dictionaryPageOffset()) {
-            $dictionaryHeader = $this->readHeader($pageStream);
+            $dictionaryHeader = PageHeader::read($pageStream, $this->options);
 
             if ($dictionaryHeader === null) {
                 throw new RuntimeException(
@@ -56,11 +52,18 @@ public function view(ColumnChunk $columnChunk, SourceStream $stream): Generator
                 );
             }
 
+            $currentPosition = ftell($pageStream);
+
+            if ($currentPosition === false) {
+                throw new RuntimeException('Cannot determine current page stream position');
+            }
+            fseek($pageStream, $currentPosition + $dictionaryHeader->compressedPageSize());
+
             yield $dictionaryHeader;
         }
 
         while (true) {
-            $dataHeader = $this->readHeader($pageStream);
+            $dataHeader = PageHeader::read($pageStream, $this->options);
 
             /** There are no more pages in given column chunk */
             if ($dataHeader === null || $dataHeader->type()->isDataPage() === false) {
@@ -79,25 +82,4 @@ public function view(ColumnChunk $columnChunk, SourceStream $stream): Generator
 
         fclose($pageStream);
     }
-
-    /**
-     * @param resource $stream
-     */
-    private function readHeader($stream): ?PageHeader
-    {
-        $currentOffset = ftell($stream);
-
-        try {
-            $thriftHeader = new ThriftPageHeader();
-            @$thriftHeader->read(new CompactProtocol(new PhpFileStream($stream)));
-
-            return PageHeader::fromThrift($thriftHeader, $this->options);
-        } catch (Throwable) {
-            if ($currentOffset !== false) {
-                fseek($stream, $currentOffset);
-            }
-
-            return null;
-        }
-    }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/ColumnReader.php b/src/lib/parquet/src/Flow/Parquet/Reader/ColumnReader.php
index c7e87a3421..09ae1bb043 100644
--- a/src/lib/parquet/src/Flow/Parquet/Reader/ColumnReader.php
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/ColumnReader.php
@@ -9,96 +9,139 @@
 use Flow\Parquet\Dremel\DremelAssembler;
 use Flow\Parquet\Dremel\ReadColumnData;
 use Flow\Parquet\Exception\InvalidArgumentException;
-use Flow\Parquet\ParquetFile\Metadata;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\ParquetFile\Page\Dictionary;
+use Flow\Parquet\ParquetFile\RowGroup;
 use Flow\Parquet\ParquetFile\Schema\Column;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
 use Generator;
 
+use function iterator_to_array;
+
 /**
- * One column's values across the row groups of a file, from $offset for at most $limit rows.
+ * One column's values in a row group, the selected rows only.
+ *
+ * @type DecodedPage = array{values: list<mixed>, definitionLevels: array<int>}
+ * @type DecodedChunk = array{pages: array<int, DecodedPage>, dictionary: ?Dictionary}
  */
 final readonly class ColumnReader
 {
     public function __construct(
-        private ColumnChunkReader $chunks,
+        private SelectedPages $pages,
         private DremelAssembler $assembler,
     ) {}
 
-    public function read(Column $column, Metadata $metadata, SourceStream $stream, ?int $limit, ?int $offset): Generator
-    {
-        $yieldedRows = 0;
-        $rowGroupOffset = 0;
-
-        foreach ($metadata->rowGroups()->all() as $rowGroup) {
-            if ($offset !== null) {
-                if (($rowGroupOffset + $rowGroup->rowsCount()) <= $offset) {
-                    $rowGroupOffset += $rowGroup->rowsCount();
+    /**
+     * The column's values at the rows $selection selects, row 0 being the group's first row.
+     *
+     * @param array<string, DecodedChunk> $decoded chunks readPhysical() returned, by leaf flat path
+     */
+    public function readRowGroup(
+        Column $column,
+        RowGroup $rowGroup,
+        int $group,
+        SourceStream $stream,
+        RowSelection $selection,
+        Indexes $indexes,
+        array $decoded = [],
+    ): Generator {
+        if (!$selection->selectsAny()) {
+            return;
+        }
 
-                    continue;
-                }
+        if ($column instanceof FlatColumn) {
+            foreach ($this->pages->trimmed(
+                $column,
+                $rowGroup,
+                $group,
+                $stream,
+                $selection,
+                $indexes,
+                $decoded[$column->flatPath()] ?? ['pages' => [], 'dictionary' => null],
+            ) as $page) {
+                yield from $this->assembler->assemble($column, new ReadColumnData($column, [
+                    $page->flatPath() => $page,
+                ]));
             }
-            $skipRows = $offset !== null ? $offset - $rowGroupOffset : 0;
-
-            if ($column instanceof FlatColumn) {
-                $rowsSkipped = 0;
-
-                foreach ($this->chunks->read(
-                    $rowGroup->getColumnChunk($column),
-                    $column,
-                    $stream,
-                ) as $flatColumnValues) {
-                    $columnData = new ReadColumnData($column, [$flatColumnValues->flatPath() => $flatColumnValues]);
-
-                    // @mago-ignore analysis:mixed-assignment
-                    foreach ($this->assembler->assemble($column, $columnData) as $row) {
-                        if ($skipRows > 0 && $rowsSkipped < $skipRows) {
-                            $rowsSkipped++;
-
-                            continue;
-                        }
-
-                        if ($limit !== null && $yieldedRows >= $limit) {
-                            return;
-                        }
-                        yield $row;
-                        $yieldedRows++;
-                    }
-                }
-            } elseif ($column instanceof NestedColumn) {
-                $flatData = [];
-
-                foreach ($column->childrenFlat() as $child) {
-                    $flatData[] = new PagedFlatColumnValues($child, $this->chunks->read(
-                        $rowGroup->getColumnChunk($child),
-                        $child,
-                        $stream,
-                    ));
-                }
 
-                $columnData = new ReadColumnData($column, $flatData);
+            return;
+        }
 
-                $rowsSkipped = 0;
+        if (!$column instanceof NestedColumn) {
+            throw new InvalidArgumentException('Column must be instance of FlatColumn or NestedColumn');
+        }
 
-                // @mago-ignore analysis:mixed-assignment
-                foreach ($this->assembler->assemble($column, $columnData) as $row) {
-                    if ($skipRows > 0 && $rowsSkipped < $skipRows) {
-                        $rowsSkipped++;
+        $flatData = [];
+
+        foreach ($column->childrenFlat() as $child) {
+            $flatData[] = new PagedFlatColumnValues($child, $this->pages->trimmed(
+                $child,
+                $rowGroup,
+                $group,
+                $stream,
+                $selection,
+                $indexes,
+                $decoded[$child->flatPath()] ?? ['pages' => [], 'dictionary' => null],
+            ));
+        }
 
-                        continue;
-                    }
+        yield from $this->assembler->assemble($column, new ReadColumnData($column, $flatData));
+    }
 
-                    if ($limit !== null && $yieldedRows >= $limit) {
-                        return;
+    /**
+     * The leaf's undecoded physical values at the rows $selection selects, null where the leaf or an ancestor is null,
+     * and the whole decoded pages it read, keyed by the row of the group each starts at, with their dictionary, for
+     * readRowGroup() to serve without reading them again.
+     *
+     * @return array{chunk: DecodedChunk, values: list<mixed>}
+     */
+    public function readPhysical(
+        FlatColumn $leaf,
+        RowGroup $rowGroup,
+        int $group,
+        SourceStream $stream,
+        RowSelection $selection,
+        Indexes $indexes,
+    ): array {
+        if ($leaf->maxRepetitionsLevel() > 0) {
+            throw new InvalidArgumentException(
+                'Column "' . $leaf->flatPath() . '" lies inside a list or a map, where a row holds no single value',
+            );
+        }
+
+        $chunk = ['pages' => [], 'dictionary' => null];
+        $values = [];
+
+        if (!$selection->selectsAny()) {
+            return ['chunk' => $chunk, 'values' => $values];
+        }
+
+        $maxDefinitionLevel = $leaf->repetitions()->maxDefinitionLevel();
+        $pages = $this->pages->read($leaf, $rowGroup, $group, $stream, $selection, $indexes, $chunk);
+
+        foreach ($pages as $firstRow => [$page, $pageSelection]) {
+            $pageValues = iterator_to_array($page->rawValues(), false);
+            $definitionLevels = $page->definitionLevels();
+            $chunk['pages'][$firstRow] = ['values' => $pageValues, 'definitionLevels' => $definitionLevels];
+            $row = 0;
+            $valueIndex = 0;
+
+            foreach ($pageSelection->selectors() as $selector) {
+                for ($end = $row + $selector->rowCount; $row < $end; $row++) {
+                    $defined = $definitionLevels[$row] === $maxDefinitionLevel;
+
+                    if (!$selector->skip) {
+                        $values[] = $defined ? $pageValues[$valueIndex] : null;
                     }
-                    yield $row;
-                    $yieldedRows++;
+
+                    $valueIndex += $defined ? 1 : 0;
                 }
-            } else {
-                throw new InvalidArgumentException('Column must be instance of FlatColumn or NestedColumn');
             }
-
-            $rowGroupOffset += $rowGroup->rowsCount();
         }
+
+        $chunk['dictionary'] = $pages->getReturn();
+
+        return ['chunk' => $chunk, 'values' => $values];
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/FilteredBatches.php b/src/lib/parquet/src/Flow/Parquet/Reader/FilteredBatches.php
new file mode 100644
index 0000000000..223cff83c8
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/FilteredBatches.php
@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Evaluation\FilterEvaluator;
+use Generator;
+
+use function array_fill_keys;
+use function array_flip;
+use function array_intersect_key;
+use function array_keys;
+use function array_slice;
+use function array_values;
+use function count;
+use function in_array;
+use function min;
+
+/**
+ * The matching rows of a read's batches (every row without an evaluator), offset and limit counted over them,
+ * rechunked to the batch size; it stops pulling batches at the limit.
+ */
+final readonly class FilteredBatches
+{
+    /**
+     * @param list<string> $columns the columns returned
+     * @param int<1, max> $batchSize
+     */
+    public function __construct(
+        private ?FilterEvaluator $evaluator,
+        private array $columns,
+        private int $offset = 0,
+        private ?int $limit = null,
+        private int $batchSize = 1024,
+    ) {
+        if ($columns === []) {
+            throw new InvalidArgumentException('A filtered read returns at least one column');
+        }
+    }
+
+    /**
+     * The columns each batch must hold: the returned ones and the filter's root columns.
+     *
+     * @return list<string>
+     */
+    public function columns(): array
+    {
+        $columns = $this->columns;
+
+        foreach ($this->evaluator?->roots() ?? [] as $root) {
+            if (!in_array($root, $columns, true)) {
+                $columns[] = $root;
+            }
+        }
+
+        return $columns;
+    }
+
+    /**
+     * @param iterable<array<string, list<mixed>>> $batches
+     *
+     * @return Generator<int, array<string, list<mixed>>>
+     */
+    public function filter(iterable $batches): Generator
+    {
+        if ($this->limit === 0) {
+            return;
+        }
+
+        $skip = $this->offset;
+        $remaining = $this->limit;
+        $buffer = array_fill_keys($this->columns, []);
+        $buffered = 0;
+
+        foreach ($batches as $batch) {
+            $mask = $this->evaluator?->mask($batch) ?? array_keys($batch[$this->columns[0]]);
+
+            if ($skip > 0) {
+                $skipped = min($skip, count($mask));
+                $mask = array_slice($mask, $skipped);
+                $skip -= $skipped;
+            }
+
+            if ($remaining !== null) {
+                $mask = array_slice($mask, 0, $remaining);
+                $remaining -= count($mask);
+            }
+
+            $whole = count($mask) === count($batch[$this->columns[0]]);
+            $rows = $whole ? [] : array_flip($mask);
+
+            foreach ($this->columns as $column) {
+                $selected = $whole ? $batch[$column] : array_values(array_intersect_key($batch[$column], $rows));
+                $buffer[$column] = $buffer[$column] === [] ? $selected : [...$buffer[$column], ...$selected];
+            }
+
+            $buffered += count($mask);
+
+            while ($buffered >= $this->batchSize) {
+                $chunk = [];
+
+                foreach ($this->columns as $column) {
+                    $chunk[$column] = array_slice($buffer[$column], 0, $this->batchSize);
+                    $buffer[$column] = array_slice($buffer[$column], $this->batchSize);
+                }
+
+                $buffered -= $this->batchSize;
+
+                yield $chunk;
+            }
+
+            if ($remaining === 0) {
+                break;
+            }
+        }
+
+        if ($buffered > 0) {
+            yield $buffer;
+        }
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/PageRun.php b/src/lib/parquet/src/Flow/Parquet/Reader/PageRun.php
new file mode 100644
index 0000000000..c344ebec9a
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/PageRun.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Parquet\Exception\RuntimeException;
+
+/**
+ * Adjacent pages of a column chunk read in one SourceStream::read: the file bytes [start, end).
+ */
+final readonly class PageRun
+{
+    /**
+     * @var positive-int
+     */
+    public int $length;
+
+    public function __construct(
+        public int $start,
+        public int $end,
+    ) {
+        $length = $end - $start;
+
+        if ($length < 1) {
+            throw new RuntimeException('The offset index locates a page of no bytes at offset ' . $start);
+        }
+
+        $this->length = $length;
+    }
+
+    public function extendedTo(int $end): self
+    {
+        return new self($this->start, $end);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/BloomFilterPruner.php b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/BloomFilterPruner.php
new file mode 100644
index 0000000000..06a22bcfe4
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/BloomFilterPruner.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader\Pruning;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\BloomEvaluator;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+
+/**
+ * Drops the row groups whose bloom filters prove no row matches. It proves no match, so matched is unchanged; a group
+ * that selects no row, or whose selected rows are all matched already, reads no filter.
+ */
+final readonly class BloomFilterPruner implements Pruner
+{
+    public function __construct(
+        private RowGroupChunks $chunks,
+        private Indexes $indexes,
+    ) {}
+
+    public function prune(BoundFilter $filter, PrunedRows $rows): PrunedRows
+    {
+        $rowCounts = $this->chunks->rowCounts();
+
+        $kept = [];
+        $matched = $rows->matched->split($rowCounts);
+
+        foreach ($rows->selected->split($rowCounts) as $rowGroup => $groupSelection) {
+            $never =
+                $groupSelection->selectsAny()
+                && !$matched[$rowGroup]->contains($groupSelection)
+                && BloomEvaluator::evaluate($filter, $this->indexes, $rowGroup) === Truth::Never;
+            $kept[] = new RowSelector($rowCounts[$rowGroup], $never);
+        }
+
+        $selected = $rows->selected->intersection(new RowSelection(...$kept));
+
+        return new PrunedRows($selected, $selected->intersection($rows->matched));
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/PageIndexPruner.php b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/PageIndexPruner.php
new file mode 100644
index 0000000000..1f731569da
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/PageIndexPruner.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader\Pruning;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\PageZoneMaps;
+use Flow\Parquet\Filter\Evaluation\StatisticsEvaluator;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\ParquetFile\PageIndex\PageIndex;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+
+use function array_keys;
+use function count;
+use function sort;
+
+/**
+ * A row group is cut at the page boundaries of every filtered column; each part is evaluated with, per column, the
+ * page holding it. A group where a filtered column has no usable page index is kept whole; a group whose selected rows
+ * are all matched already reads no index.
+ */
+final readonly class PageIndexPruner implements Pruner
+{
+    public function __construct(
+        private RowGroupChunks $chunks,
+        private Indexes $indexes,
+    ) {}
+
+    public function prune(BoundFilter $filter, PrunedRows $rows): PrunedRows
+    {
+        $columns = $filter->columns();
+
+        if ($columns === []) {
+            return $rows;
+        }
+
+        $rowCounts = $this->chunks->rowCounts();
+
+        $kept = [];
+        $proven = [];
+        $matched = $rows->matched->split($rowCounts);
+
+        foreach ($rows->selected->split($rowCounts) as $rowGroup => $groupSelection) {
+            $groupRows = $rowCounts[$rowGroup];
+
+            if (!$groupSelection->selectsAny()) {
+                $kept[] = new RowSelector($groupRows, true);
+                $proven[] = new RowSelector($groupRows, true);
+
+                continue;
+            }
+
+            if ($matched[$rowGroup]->contains($groupSelection)) {
+                $kept[] = new RowSelector($groupRows, false);
+                $proven[] = new RowSelector($groupRows, true);
+
+                continue;
+            }
+
+            $pageIndexes = [];
+            $boundaries = [$groupRows => true];
+
+            foreach ($columns as $column) {
+                $pageIndex = PageIndex::of(
+                    $this->indexes->columnIndex($rowGroup, $column),
+                    $this->indexes->offsetIndex($rowGroup, $column),
+                    $groupRows,
+                );
+
+                if ($pageIndex === null) {
+                    $pageIndexes = null;
+
+                    break;
+                }
+
+                $pageIndexes[$column->flatPath()] = $pageIndex;
+
+                foreach ($pageIndex->offsetIndex->pages as $page) {
+                    $boundaries[$page->firstRowIndex] = true;
+                }
+            }
+
+            if ($pageIndexes === null) {
+                $kept[] = new RowSelector($groupRows, false);
+                $proven[] = new RowSelector($groupRows, true);
+
+                continue;
+            }
+
+            $starts = array_keys($boundaries);
+            sort($starts);
+            $parts = [];
+
+            for ($i = 0; ($i + 1) < count($starts); $i++) {
+                $parts[] = $starts[$i + 1] - $starts[$i];
+            }
+
+            $zones = new PageZoneMaps($this->chunks, $pageIndexes);
+
+            foreach ($groupSelection->split($parts) as $part => $partSelection) {
+                $truth = $partSelection->selectsAny()
+                    ? StatisticsEvaluator::evaluate($filter, $zones->at($starts[$part]))
+                    : Truth::Never;
+                $kept[] = new RowSelector($parts[$part], $truth === Truth::Never);
+                $proven[] = new RowSelector($parts[$part], $truth !== Truth::Always);
+            }
+        }
+
+        $selected = $rows->selected->intersection(new RowSelection(...$kept));
+
+        return new PrunedRows($selected, $selected->intersection($rows->matched->union(new RowSelection(...$proven))));
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/PrunedRows.php b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/PrunedRows.php
new file mode 100644
index 0000000000..b73086c245
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/PrunedRows.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader\Pruning;
+
+use Flow\Parquet\Reader\RowSelection;
+
+final readonly class PrunedRows
+{
+    public function __construct(
+        public RowSelection $selected,
+        public RowSelection $matched,
+    ) {}
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/Pruner.php b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/Pruner.php
new file mode 100644
index 0000000000..58ad8dc298
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/Pruner.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader\Pruning;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+
+interface Pruner
+{
+    /**
+     * Selects a subset of $rows->selected, evaluating only the units that still select a row; matched is the selected
+     * rows of $rows->matched and of the units it proves to match.
+     */
+    public function prune(BoundFilter $filter, PrunedRows $rows): PrunedRows;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/RowGroupStatisticsPruner.php b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/RowGroupStatisticsPruner.php
new file mode 100644
index 0000000000..58ba99e98a
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/Pruning/RowGroupStatisticsPruner.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader\Pruning;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\RowGroupZoneMaps;
+use Flow\Parquet\Filter\Evaluation\StatisticsEvaluator;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+
+final readonly class RowGroupStatisticsPruner implements Pruner
+{
+    public function __construct(
+        private RowGroupChunks $chunks,
+    ) {}
+
+    public function prune(BoundFilter $filter, PrunedRows $rows): PrunedRows
+    {
+        $rowCounts = $this->chunks->rowCounts();
+
+        $kept = [];
+        $proven = [];
+
+        foreach ($rows->selected->split($rowCounts) as $rowGroup => $groupSelection) {
+            $truth = $groupSelection->selectsAny()
+                ? StatisticsEvaluator::evaluate($filter, new RowGroupZoneMaps($this->chunks, $rowGroup))
+                : Truth::Never;
+            $kept[] = new RowSelector($rowCounts[$rowGroup], $truth === Truth::Never);
+            $proven[] = new RowSelector($rowCounts[$rowGroup], $truth !== Truth::Always);
+        }
+
+        $selected = $rows->selected->intersection(new RowSelection(...$kept));
+
+        return new PrunedRows($selected, $selected->intersection($rows->matched->union(new RowSelection(...$proven))));
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/ReadPlan.php b/src/lib/parquet/src/Flow/Parquet/Reader/ReadPlan.php
new file mode 100644
index 0000000000..b6d62c93fd
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/ReadPlan.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+
+final readonly class ReadPlan
+{
+    /**
+     * @param RowSelection $selection rows to read
+     * @param RowSelection $matched rows proven to match the filter, within $selection: a hint an engine may ignore,
+     *                              evaluating $rowFilter on them as well (arrow does)
+     * @param Indexes $indexes the file's page indexes, read once for planning and reading
+     * @param null|BoundFilter $rowFilter evaluated on every selected row outside $matched; a row is read when true
+     * @param null|int $limit the rows returned at most, counted after $rowFilter
+     */
+    public function __construct(
+        public RowSelection $selection,
+        public RowSelection $matched,
+        public Indexes $indexes,
+        public ?BoundFilter $rowFilter = null,
+        public ?int $limit = null,
+    ) {
+        if ($selection->totalRows() !== $matched->totalRows()) {
+            throw new InvalidArgumentException('A read plan selection and its matched rows must cover the same rows');
+        }
+
+        if (!$selection->contains($matched)) {
+            throw new InvalidArgumentException('A read plan can match only rows it selects');
+        }
+
+        if ($limit !== null && $limit < 0) {
+            throw new InvalidArgumentException('A read plan limit cannot be negative, got ' . $limit);
+        }
+    }
+
+    /**
+     * Every row of the window, each a match.
+     */
+    public static function window(int $rows, Indexes $indexes, int $offset = 0, ?int $limit = null): self
+    {
+        $selection = RowSelection::window($rows, $offset, $limit);
+
+        return new self($selection, $selection, $indexes);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/ReadPlanner.php b/src/lib/parquet/src/Flow/Parquet/Reader/ReadPlanner.php
new file mode 100644
index 0000000000..d495674858
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/ReadPlanner.php
@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\ParquetFile\Footer;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\Reader\Pruning\BloomFilterPruner;
+use Flow\Parquet\Reader\Pruning\PageIndexPruner;
+use Flow\Parquet\Reader\Pruning\PrunedRows;
+use Flow\Parquet\Reader\Pruning\RowGroupStatisticsPruner;
+
+final readonly class ReadPlanner
+{
+    /**
+     * The rows to read: the file's rows from $rawOffset on, minus the row groups and pages whose statistics or bloom
+     * filters prove no row matches $filter. The conjuncts of $filter the file answers exactly are evaluated on rows
+     * (ReadPlan::$rowFilter); the caller evaluates the rest.
+     *
+     * @param int $rawOffset rows of the file skipped before any is evaluated
+     * @param null|int $limit rows returned at most, counted after the row filter: refused beside a filter whose
+     *                        conjuncts are not all evaluated on rows, as the rows returned would still be filtered
+     */
+    public function plan(
+        Footer $footer,
+        Indexes $indexes,
+        ?BoundFilter $filter,
+        int $rawOffset = 0,
+        ?int $limit = null,
+    ): ReadPlan {
+        $rows = $footer->rowsNumber();
+
+        if ($filter === null || $limit === 0) {
+            return ReadPlan::window($rows, $indexes, $rawOffset, $limit);
+        }
+
+        if ($limit !== null && !$filter->answersEveryConjunct()) {
+            throw new InvalidArgumentException(
+                'A limit counts the rows returned, which a plan cannot honour unless the file answers every conjunct '
+                . 'of its filter exactly',
+            );
+        }
+
+        $chunks = $footer->rowGroupChunks($filter->columns());
+        $pruned = new PrunedRows(RowSelection::window($rows, $rawOffset), RowSelection::none($rows));
+
+        foreach ([
+            new RowGroupStatisticsPruner($chunks),
+            new BloomFilterPruner($chunks, $indexes),
+            new PageIndexPruner($chunks, $indexes),
+        ] as $pruner) {
+            $pruned = $pruner->prune($filter, $pruned);
+        }
+
+        return new ReadPlan($pruned->selected, $pruned->matched, $indexes, $filter->rowFilter(), $limit);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/RowSelection.php b/src/lib/parquet/src/Flow/Parquet/Reader/RowSelection.php
new file mode 100644
index 0000000000..ebe4f4d7ff
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/RowSelection.php
@@ -0,0 +1,328 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+
+use function array_key_last;
+use function array_pop;
+use function array_sum;
+use function count;
+use function min;
+use function sprintf;
+
+/**
+ * File-absolute rows: the selectors cover every row of the file, in order, adjacent selectors merged.
+ */
+final readonly class RowSelection
+{
+    /**
+     * @var list<RowSelector>
+     */
+    private array $selectors;
+
+    /**
+     * @var list<int> the first row of each selector
+     */
+    private array $starts;
+
+    public function __construct(RowSelector ...$selectors)
+    {
+        /** @var list<RowSelector> $merged */
+        $merged = [];
+
+        foreach ($selectors as $selector) {
+            if ($selector->rowCount === 0) {
+                continue;
+            }
+
+            $previous = array_pop($merged);
+
+            if ($previous !== null && $previous->skip === $selector->skip) {
+                $merged[] = new RowSelector($previous->rowCount + $selector->rowCount, $selector->skip);
+
+                continue;
+            }
+
+            if ($previous !== null) {
+                $merged[] = $previous;
+            }
+
+            $merged[] = $selector;
+        }
+
+        $starts = [];
+        $row = 0;
+
+        foreach ($merged as $selector) {
+            $starts[] = $row;
+            $row += $selector->rowCount;
+        }
+
+        $this->selectors = $merged;
+        $this->starts = $starts;
+    }
+
+    public static function all(int $rows): self
+    {
+        return new self(new RowSelector($rows, false));
+    }
+
+    public static function none(int $rows): self
+    {
+        return new self(new RowSelector($rows, true));
+    }
+
+    /**
+     * The rows from $offset on, $limit of them at most.
+     */
+    public static function window(int $rows, int $offset = 0, ?int $limit = null): self
+    {
+        $offset = min($offset, $rows);
+        $selected = min($limit ?? ($rows - $offset), $rows - $offset);
+
+        return new self(
+            new RowSelector($offset, true),
+            new RowSelector($selected, false),
+            new RowSelector($rows - $offset - $selected, true),
+        );
+    }
+
+    /**
+     * Whether every row the other selection selects is selected here.
+     */
+    public function contains(self $other): bool
+    {
+        return $other->intersection($this)->rowCount() === $other->rowCount();
+    }
+
+    public function difference(self $other): self
+    {
+        return $this->combine($other, static fn(bool $leftSkips, bool $rightSkips): bool => $leftSkips || !$rightSkips);
+    }
+
+    public function head(int $rows): self
+    {
+        $selectors = [];
+
+        foreach ($this->selectors as $selector) {
+            $taken = $selector->skip ? 0 : min($rows, $selector->rowCount);
+            $selectors[] = new RowSelector($taken, false);
+            $selectors[] = new RowSelector($selector->rowCount - $taken, true);
+            $rows -= $taken;
+        }
+
+        return new self(...$selectors);
+    }
+
+    public function intersection(self $other): self
+    {
+        return $this->combine($other, static fn(bool $leftSkips, bool $rightSkips): bool => $leftSkips || $rightSkips);
+    }
+
+    /**
+     * The selected rows whose entry is true, one entry per selected row in order.
+     *
+     * @param list<bool> $mask
+     */
+    public function masked(array $mask): self
+    {
+        if (count($mask) !== $this->rowCount()) {
+            throw new InvalidArgumentException(sprintf(
+                'A mask of %d rows cannot narrow a selection of %d rows',
+                count($mask),
+                $this->rowCount(),
+            ));
+        }
+
+        $selectors = [];
+        $row = 0;
+
+        foreach ($this->selectors as $selector) {
+            if ($selector->skip) {
+                $selectors[] = $selector;
+
+                continue;
+            }
+
+            $run = 0;
+            $skip = !$mask[$row];
+
+            for ($end = $row + $selector->rowCount; $row < $end; $row++) {
+                if (!$mask[$row] !== $skip) {
+                    $selectors[] = new RowSelector($run, $skip);
+                    $run = 0;
+                    $skip = !$skip;
+                }
+
+                $run++;
+            }
+
+            $selectors[] = new RowSelector($run, $skip);
+        }
+
+        return new self(...$selectors);
+    }
+
+    public function union(self $other): self
+    {
+        return $this->combine($other, static fn(bool $leftSkips, bool $rightSkips): bool => $leftSkips && $rightSkips);
+    }
+
+    /**
+     * Rows selected.
+     *
+     * @return non-negative-int
+     */
+    public function rowCount(): int
+    {
+        $rows = 0;
+
+        foreach ($this->selectors as $selector) {
+            $rows += $selector->skip ? 0 : $selector->rowCount;
+        }
+
+        return $rows;
+    }
+
+    /**
+     * @return list<RowSelector>
+     */
+    public function selectors(): array
+    {
+        return $this->selectors;
+    }
+
+    /**
+     * $rows rows from row $offset on, row 0 being row $offset.
+     */
+    public function slice(int $offset, int $rows): self
+    {
+        if ($offset < 0 || $rows < 0 || ($offset + $rows) > $this->totalRows()) {
+            throw new InvalidArgumentException(sprintf(
+                'Rows %d to %d lie outside a selection of %d rows',
+                $offset,
+                $offset + $rows,
+                $this->totalRows(),
+            ));
+        }
+
+        $low = 0;
+        $high = count($this->starts) - 1;
+
+        while ($low < $high) {
+            $middle = ($low + $high + 1) >> 1;
+
+            if ($this->starts[$middle] <= $offset) {
+                $low = $middle;
+            } else {
+                $high = $middle - 1;
+            }
+        }
+
+        $selectors = [];
+
+        for ($index = $low, $row = $offset, $end = $offset + $rows; $row < $end; $index++) {
+            $taken = min($end, $this->starts[$index] + $this->selectors[$index]->rowCount) - $row;
+            $selectors[] = new RowSelector($taken, $this->selectors[$index]->skip);
+            $row += $taken;
+        }
+
+        return new self(...$selectors);
+    }
+
+    /**
+     * One selection per consecutive part of the given row counts, row 0 of each being the part's first row.
+     *
+     * @param list<int> $rowCounts
+     *
+     * @return list<self>
+     */
+    public function split(array $rowCounts): array
+    {
+        if (array_sum($rowCounts) !== $this->totalRows()) {
+            throw new InvalidArgumentException(sprintf(
+                'A selection of %d rows cannot be split into parts of %d rows',
+                $this->totalRows(),
+                array_sum($rowCounts),
+            ));
+        }
+
+        $parts = [];
+        $offset = 0;
+
+        foreach ($rowCounts as $rowCount) {
+            $parts[] = $this->slice($offset, $rowCount);
+            $offset += $rowCount;
+        }
+
+        return $parts;
+    }
+
+    public function selectsAny(): bool
+    {
+        foreach ($this->selectors as $selector) {
+            if (!$selector->skip) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Rows covered, selected or skipped.
+     */
+    public function totalRows(): int
+    {
+        $last = array_key_last($this->selectors);
+
+        return $last === null ? 0 : $this->starts[$last] + $this->selectors[$last]->rowCount;
+    }
+
+    /**
+     * @param callable(bool, bool): bool $skip whether a row is skipped, from whether each selection skips it
+     */
+    private function combine(self $other, callable $skip): self
+    {
+        if ($this->totalRows() !== $other->totalRows()) {
+            throw new InvalidArgumentException(sprintf(
+                'Row selections of %d and %d rows cannot be combined',
+                $this->totalRows(),
+                $other->totalRows(),
+            ));
+        }
+
+        $left = $this->selectors;
+        $right = $other->selectors;
+
+        if ($left === []) {
+            return new self();
+        }
+
+        $combined = [];
+        $i = 0;
+        $j = 0;
+        $leftRemaining = $left[0]->rowCount;
+        $rightRemaining = $right[0]->rowCount;
+
+        while ($i < count($left) && $j < count($right)) {
+            $rows = min($leftRemaining, $rightRemaining);
+            $combined[] = new RowSelector($rows, $skip($left[$i]->skip, $right[$j]->skip));
+            $leftRemaining -= $rows;
+            $rightRemaining -= $rows;
+
+            if ($leftRemaining === 0 && ++$i < count($left)) {
+                $leftRemaining = $left[$i]->rowCount;
+            }
+
+            if ($rightRemaining === 0 && ++$j < count($right)) {
+                $rightRemaining = $right[$j]->rowCount;
+            }
+        }
+
+        return new self(...$combined);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/RowSelector.php b/src/lib/parquet/src/Flow/Parquet/Reader/RowSelector.php
new file mode 100644
index 0000000000..a8fd3883bc
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/RowSelector.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+
+final readonly class RowSelector
+{
+    /**
+     * @var non-negative-int
+     */
+    public int $rowCount;
+
+    public function __construct(
+        int $rowCount,
+        public bool $skip,
+    ) {
+        if ($rowCount < 0) {
+            throw new InvalidArgumentException('Row selector row count must be 0 or more, got ' . $rowCount);
+        }
+
+        $this->rowCount = $rowCount;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Reader/SelectedPages.php b/src/lib/parquet/src/Flow/Parquet/Reader/SelectedPages.php
new file mode 100644
index 0000000000..a768b1e713
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Reader/SelectedPages.php
@@ -0,0 +1,176 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Reader;
+
+use Flow\Filesystem\SourceStream;
+use Flow\Parquet\Dremel\ColumnData\ReadFlatColumnValues;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\ParquetFile\Page\Dictionary;
+use Flow\Parquet\ParquetFile\RowGroup;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Generator;
+
+use function array_fill;
+use function array_key_exists;
+use function count;
+use function sprintf;
+
+/**
+ * @import-type DecodedChunk from ColumnReader
+ * @import-type DecodedPage from ColumnReader
+ */
+final readonly class SelectedPages
+{
+    public function __construct(
+        private ColumnChunkReader $chunks,
+    ) {}
+
+    /**
+     * The leaf's pages trimmed to the selected rows, so every leaf of every column yields the same rows.
+     *
+     * @param DecodedChunk $decoded
+     *
+     * @return Generator<int, ReadFlatColumnValues>
+     */
+    public function trimmed(
+        FlatColumn $leaf,
+        RowGroup $rowGroup,
+        int $group,
+        SourceStream $stream,
+        RowSelection $selection,
+        Indexes $indexes,
+        array $decoded,
+    ): Generator {
+        foreach ($this->read($leaf, $rowGroup, $group, $stream, $selection, $indexes, $decoded) as [
+            $page,
+            $pageSelection,
+        ]) {
+            yield $pageSelection->rowCount() === $pageSelection->totalRows() ? $page : $page->select($pageSelection);
+        }
+    }
+
+    /**
+     * The leaf's whole pages holding a selected row, keyed by the row of the group each starts at, each with the rows
+     * of it $selection selects. A page in $decoded is served from it; the others are read, through the offset index
+     * when the selection skips rows or decoded pages spare reads. Returns the pages' dictionary.
+     *
+     * @param DecodedChunk $decoded
+     *
+     * @return Generator<int, array{ReadFlatColumnValues, RowSelection}, mixed, ?Dictionary>
+     */
+    public function read(
+        FlatColumn $leaf,
+        RowGroup $rowGroup,
+        int $group,
+        SourceStream $stream,
+        RowSelection $selection,
+        Indexes $indexes,
+        array $decoded,
+    ): Generator {
+        $rows = $selection->totalRows();
+        $whole = $selection->rowCount() === $rows;
+        $offsetIndex = $whole && $decoded['pages'] === [] ? null : $indexes->offsetIndex($group, $leaf);
+
+        if ($offsetIndex === null) {
+            $pages = $decoded['pages'] === []
+                ? $this->chunks->read($rowGroup->getColumnChunk($leaf), $leaf, $stream)
+                : self::decodedPages($leaf, $decoded);
+
+            foreach ($pages as $firstRow => $page) {
+                $pageRows = $page->rowsCount();
+
+                if (($firstRow + $pageRows) > $rows) {
+                    throw new RuntimeException(sprintf(
+                        'Row group %d decodes more than the %d rows its metadata declares',
+                        $group,
+                        $rows,
+                    ));
+                }
+
+                $pageSelection = $selection->slice($firstRow, $pageRows);
+
+                if ($pageSelection->selectsAny()) {
+                    yield $firstRow => [$page, $pageSelection];
+                }
+            }
+
+            return $pages->getReturn();
+        }
+
+        $selected = [];
+        $fetched = [];
+
+        foreach ($offsetIndex->pages as $page => $location) {
+            $pageSelection = $selection->slice($location->firstRowIndex, $offsetIndex->pageRows($page, $rows));
+
+            if ($pageSelection->selectsAny()) {
+                $selected[$location->firstRowIndex] = $pageSelection;
+
+                if (!array_key_exists($location->firstRowIndex, $decoded['pages'])) {
+                    $fetched[] = $page;
+                }
+            }
+        }
+
+        $read = $this->chunks->read(
+            $rowGroup->getColumnChunk($leaf),
+            $leaf,
+            $stream,
+            $offsetIndex,
+            $fetched,
+            $decoded['dictionary'],
+        );
+
+        foreach ($selected as $firstRow => $pageSelection) {
+            if (array_key_exists($firstRow, $decoded['pages'])) {
+                yield $firstRow => [self::decodedPage($leaf, $decoded['pages'][$firstRow]), $pageSelection];
+
+                continue;
+            }
+
+            /** @var ReadFlatColumnValues $page one per fetched page, or the read throws */
+            $page = $read->current();
+
+            yield $firstRow => [$page, $pageSelection];
+            $read->next();
+        }
+
+        return $fetched === [] ? $decoded['dictionary'] : $read->getReturn();
+    }
+
+    /**
+     * @param DecodedChunk $decoded
+     *
+     * @return Generator<int, ReadFlatColumnValues, mixed, ?Dictionary>
+     */
+    private static function decodedPages(FlatColumn $leaf, array $decoded): Generator
+    {
+        foreach ($decoded['pages'] as $firstRow => $page) {
+            yield $firstRow => self::decodedPage($leaf, $page);
+        }
+
+        return $decoded['dictionary'];
+    }
+
+    /**
+     * A page of a leaf outside any list: every repetition level is 0.
+     *
+     * @param DecodedPage $page
+     */
+    private static function decodedPage(FlatColumn $leaf, array $page): ReadFlatColumnValues
+    {
+        $values = $page['values'];
+
+        return new ReadFlatColumnValues(
+            $leaf,
+            (static function () use ($values): Generator {
+                yield from $values;
+            })(),
+            array_fill(0, count($page['definitionLevels']), 0),
+            $page['definitionLevels'],
+        );
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Resources/Thrift/parquet.thrift b/src/lib/parquet/src/Flow/Parquet/Resources/Thrift/parquet.thrift
index bb060bd99c..b21657b7e3 100644
--- a/src/lib/parquet/src/Flow/Parquet/Resources/Thrift/parquet.thrift
+++ b/src/lib/parquet/src/Flow/Parquet/Resources/Thrift/parquet.thrift
@@ -34,7 +34,7 @@ enum Type {
   BOOLEAN = 0;
   INT32 = 1;
   INT64 = 2;
-  INT96 = 3;  // deprecated, only used by legacy implementations.
+  INT96 = 3;  // deprecated, new Parquet writers should not write data in INT96
   FLOAT = 4;
   DOUBLE = 5;
   BYTE_ARRAY = 6;
@@ -42,7 +42,7 @@ enum Type {
 }
 
 /**
- * DEPRECATED: Common types used by frameworks(e.g. hive, pig) using parquet.
+ * DEPRECATED: Common types used by frameworks (e.g. Hive, Pig) using parquet.
  * ConvertedType is superseded by LogicalType.  This enum should not be extended.
  *
  * See LogicalTypes.md for conversion between ConvertedType and LogicalType.
@@ -238,6 +238,29 @@ struct SizeStatistics {
    3: optional list<i64> definition_level_histogram;
 }
 
+/**
+ * Bounding box for GEOMETRY or GEOGRAPHY type in the representation of min/max
+ * value pair of coordinates from each axis.
+ */
+struct BoundingBox {
+  1: required double xmin;
+  2: required double xmax;
+  3: required double ymin;
+  4: required double ymax;
+  5: optional double zmin;
+  6: optional double zmax;
+  7: optional double mmin;
+  8: optional double mmax;
+}
+
+/** Statistics specific to Geometry and Geography logical types */
+struct GeospatialStatistics {
+  /** A bounding box of geospatial instances */
+  1: optional BoundingBox bbox;
+  /** Geospatial type codes of all instances, or an empty list if not known */
+  2: optional list<i32> geospatial_types;
+}
+
 /**
  * Statistics per row group and per page
  * All fields are optional.
@@ -287,16 +310,23 @@ struct Statistics {
    7: optional bool is_max_value_exact;
    /** If true, min_value is the actual minimum value for a column */
    8: optional bool is_min_value_exact;
+   /**
+    * Count of NaN values in the column; only present if physical type is FLOAT
+    * or DOUBLE, or logical type is FLOAT16.
+    * If this field is not present, readers MUST assume NaNs may be present
+    * (i.e. MUST assume nan_count > 0 and MAY NOT assume nan_count == 0).
+    */
+   9: optional i64 nan_count;
 }
 
 /** Empty structs to use as logical type annotations */
 struct StringType {}  // allowed for BYTE_ARRAY, must be encoded with UTF-8
-struct UUIDType {}    // allowed for FIXED[16], must encoded raw UUID bytes
+struct UUIDType {}    // allowed for FIXED[16], must be encoded as raw UUID bytes
 struct MapType {}     // see LogicalTypes.md
 struct ListType {}    // see LogicalTypes.md
 struct EnumType {}    // allowed for BYTE_ARRAY, must be encoded with UTF-8
 struct DateType {}    // allowed for INT32
-struct Float16Type {} // allowed for FIXED[2], must encoded raw FLOAT16 bytes
+struct Float16Type {} // allowed for FIXED[2], must be encoded as raw FLOAT16 bytes (see LogicalTypes.md)
 
 /**
  * Logical type to annotate a column that is always null.
@@ -336,7 +366,7 @@ union TimeUnit {
 /**
  * Timestamp logical type annotation
  *
- * Allowed for physical types: INT64
+ * Allowed for physical types: INT64 and FIXED_LEN_BYTE_ARRAY with `type_length` = 12.
  */
 struct TimestampType {
   1: required bool isAdjustedToUTC
@@ -381,6 +411,75 @@ struct JsonType {
 struct BsonType {
 }
 
+/**
+ * Embedded Variant logical type annotation
+ */
+struct VariantType {
+  // The version of the variant specification that the variant was
+  // written with.
+  1: optional i8 specification_version
+}
+
+/** Edge interpolation algorithm for Geography logical type */
+enum EdgeInterpolationAlgorithm {
+  SPHERICAL = 0;
+  VINCENTY = 1;
+  THOMAS = 2;
+  ANDOYER = 3;
+  KARNEY = 4;
+}
+
+/**
+ * Embedded Geometry logical type annotation
+ *
+ * Geospatial features in the Well-Known Binary (WKB) format and `edges` interpolation
+ * is always linear/planar.
+ *
+ * A custom CRS can be set by the crs field. If unset, it defaults to "OGC:CRS84",
+ * which means that the geometries must be stored in longitude, latitude based on
+ * the WGS84 datum.
+ *
+ * Allowed for physical type: BYTE_ARRAY.
+ *
+ * See Geospatial.md for details.
+ */
+struct GeometryType {
+  1: optional string crs;
+}
+
+/**
+ * Embedded Geography logical type annotation
+ *
+ * Geospatial features in the WKB format with an explicit (non-linear/non-planar)
+ * `edges` interpolation algorithm.
+ *
+ * A custom geographic CRS can be set by the crs field, where longitudes are
+ * bound by [-180, 180] and latitudes are bound by [-90, 90]. If unset, the CRS
+ * defaults to "OGC:CRS84".
+ *
+ * An optional algorithm can be set to correctly interpret `edges` interpolation
+ * of the geometries. If unset, the algorithm defaults to SPHERICAL.
+ *
+ * Allowed for physical type: BYTE_ARRAY.
+ *
+ * See Geospatial.md for details.
+ */
+struct GeographyType {
+  1: optional string crs;
+  2: optional EdgeInterpolationAlgorithm algorithm;
+}
+
+/**
+ * File logical type annotation
+ *
+ * Annotates a group that represents a reference to a file, or to a range of
+ * bytes that may be stored inline or in an external file.
+ *
+ * See LogicalTypes.md for details.
+ */
+struct FileType {
+}
+
 /**
  * LogicalType annotations to replace ConvertedType.
  *
@@ -411,10 +510,14 @@ union LogicalType {
   13: BsonType BSON           // use ConvertedType BSON
   14: UUIDType UUID           // no compatible ConvertedType
   15: Float16Type FLOAT16     // no compatible ConvertedType
+  16: VariantType VARIANT     // no compatible ConvertedType
+  17: GeometryType GEOMETRY   // no compatible ConvertedType
+  18: GeographyType GEOGRAPHY // no compatible ConvertedType
+  19: FileType FILE           // no compatible ConvertedType
 }
 
 /**
- * Represents a element inside a schema definition.
+ * Represents an element inside a schema definition.
  *  - if it is a group (inner node) then type is undefined and num_children is defined
  *  - if it is a primitive type (leaf) then type is defined and num_children is undefined
  * the nodes are listed in depth first traversal order.
@@ -493,15 +596,15 @@ enum Encoding {
   PLAIN = 0;
 
   /** Group VarInt encoding for INT32/INT64.
-   * This encoding is deprecated. It was never used
+   * This encoding is deprecated. It was never used.
    */
   //  GROUP_VAR_INT = 1;
 
   /**
-   * Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
+   * DEPRECATED: Dictionary encoding. The values in the dictionary are encoded in the
    * plain type.
-   * in a data page use RLE_DICTIONARY instead.
-   * in a Dictionary page use PLAIN instead
+   * For a data page use RLE_DICTIONARY instead.
+   * For a Dictionary page use PLAIN instead.
    */
   PLAIN_DICTIONARY = 2;
 
@@ -510,8 +613,9 @@ enum Encoding {
    */
   RLE = 3;
 
-  /** Bit packed encoding.  This can only be used if the data has a known max
+  /** DEPRECATED: Bit packed encoding.  This can only be used if the data has a known max
    * width.  Usable for definition/repetition levels encoding.
+   * Superseded by RLE (which is a hybrid of RLE and bit packing); see Encodings.md.
    */
   BIT_PACKED = 4;
 
@@ -545,6 +649,14 @@ enum Encoding {
       Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
    */
   BYTE_STREAM_SPLIT = 9;
+
+  /** Adaptive Lossless floating-Point (ALP) encoding for FLOAT and DOUBLE.
+      Losslessly converts decimal-like floating-point values to integers via
+      decimal scaling, then applies Frame of Reference (FOR) encoding and
+      bit-packing; values that cannot be converted losslessly are stored as
+      exceptions. See Encodings.md for the detailed specification.
+   */
+  ALP = 10;
 }
 
 /**
@@ -589,7 +701,7 @@ struct DataPageHeader {
   /**
    * Number of values, including NULLs, in this data page.
    *
-   * If a OffsetIndex is present, a page must begin at a row
+   * If an OffsetIndex is present, a page must begin at a row
    * boundary (repetition_level = 0). Otherwise, pages may begin
    * within a row (repetition_level > 0).
    **/
@@ -629,9 +741,14 @@ struct DictionaryPageHeader {
 }
 
 /**
- * New page format allowing reading levels without decompressing the data
+ * Alternate page format allowing reading levels without decompressing the data
  * Repetition and definition levels are uncompressed
  * The remaining section containing the data is compressed if is_compressed is true
+ *
+ * Implementation note - this header is not necessarily a strict improvement over
+ * `DataPageHeader` (in particular the original header might provide better compression
+ * in some scenarios). Page indexes require pages to start and end at row boundaries,
+ * regardless of which page header is used.
  **/
 struct DataPageHeaderV2 {
   /** Number of values, including NULLs, in this data page. **/
@@ -657,7 +774,7 @@ struct DataPageHeaderV2 {
 
   /**  Whether the values are compressed.
   Which means the section of the page between
-  definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included)
+  definition_levels_byte_length + repetition_levels_byte_length and compressed_page_size (included)
   is compressed with the compression_codec.
   If missing it is considered compressed */
   7: optional bool is_compressed = true;
@@ -721,10 +838,10 @@ struct PageHeader {
   /** Compressed (and potentially encrypted) page size in bytes, not including this header **/
   3: required i32 compressed_page_size
 
-  /** The 32-bit CRC checksum for the page, to be be calculated as follows:
+  /** The 32-bit CRC checksum for the page, to be calculated as follows:
    *
    * - The standard CRC32 algorithm is used (with polynomial 0x04C11DB7,
-   *   the same as in e.g. GZip).
+   *   the same as in e.g. GZIP).
    * - All page types can have a CRC (v1 and v2 data pages, dictionary pages,
    *   etc.).
    * - The CRC is computed on the serialization binary representation of the page
@@ -851,6 +968,9 @@ struct ColumnMetaData {
    * filter pushdown.
    */
   16: optional SizeStatistics size_statistics;
+
+  /** Optional statistics specific for Geometry and Geography logical types */
+  17: optional GeospatialStatistics geospatial_statistics;
 }
 
 struct EncryptionWithFooterKey {
@@ -872,10 +992,25 @@ union ColumnCryptoMetaData {
 struct ColumnChunk {
   /** File where column data is stored.  If not set, assumed to be same file as
     * metadata.  This path is relative to the current file.
+    *
+    * As of December 2025, the only known use-case for this field is writing summary
+    * parquet files (i.e. "_metadata" files).  These files consolidate footers from
+    * multiple parquet files to allow for efficient reading of footers to avoid file
+    * listing costs and prune out files that do not need to be read based on statistics.
+    *
+    * These files do not appear to have ever been formally specified in the specification.
+    * and are potentially problematic from a correctness perspective [1].
+    *
+    * [1] https://lists.apache.org/thread/ootf2kmyg3p01b1bvplpvp4ftd1bt72d
+    *
+    * There is no other known usage of this field. Specifically, there are no known
+    * reference implementations that will read externally stored column data if this field is populated
+    * within a standard parquet file. Making use of the field for this purpose is
+    * not considered part of the Parquet specification.
     **/
   1: optional string file_path
 
-  /** Deprecated: Byte offset in file_path to the ColumnMetaData
+  /** DEPRECATED: Byte offset in file_path to the ColumnMetaData
    *
    * Past use of this field has been inconsistent, with some implementations
    * using it to point to the ColumnMetaData and some using it to point to
@@ -944,6 +1079,12 @@ struct RowGroup {
 /** Empty struct to signal the order defined by the physical or logical type */
 struct TypeDefinedOrder {}
 
+/** Empty struct to signal IEEE 754 total order for floating point types */
+struct IEEE754TotalOrder {}
+
+/** Empty struct to signal chronological ordering of physical type INT96 */
+struct Int96TimestampOrder {}
+
 /**
  * Union to specify the order used for the min_value and max_value fields for a
  * column. This union takes the role of an enhanced enum that allows rich
@@ -952,6 +1093,9 @@ struct TypeDefinedOrder {}
  * Possible values are:
  * * TypeDefinedOrder - the column uses the order defined by its logical or
  *                      physical type (if there is no logical type).
+ * * IEEE754TotalOrder - the floating point column uses IEEE 754 total order.
+ *
+ * * Int96TimestampOrder - the INT96 column uses chronological timestamp order.
  *
  * If the reader does not support the value of this union, min and max stats
  * for this column should be ignored.
@@ -971,6 +1115,7 @@ union ColumnOrder {
    *   UINT64 - unsigned comparison
    *   DECIMAL - signed comparison of the represented value
    *   DATE - signed comparison
+   *   FLOAT16 - signed comparison of the represented value (*)
    *   TIME_MILLIS - signed comparison
    *   TIME_MICROS - signed comparison
    *   TIMESTAMP_MILLIS - signed comparison
@@ -981,34 +1126,111 @@ union ColumnOrder {
    *   ENUM - unsigned byte-wise comparison
    *   LIST - undefined
    *   MAP - undefined
+   *   VARIANT - undefined
+   *   GEOMETRY - undefined
+   *   GEOGRAPHY - undefined
+   *   FILE - undefined
    *
    * In the absence of logical types, the sort order is determined by the physical type:
    *   BOOLEAN - false, true
    *   INT32 - signed comparison
    *   INT64 - signed comparison
-   *   INT96 (only used for legacy timestamps) - undefined
+   *   INT96 (only used for legacy timestamps) - depends on sort order (+)
    *   FLOAT - signed comparison of the represented value (*)
    *   DOUBLE - signed comparison of the represented value (*)
    *   BYTE_ARRAY - unsigned byte-wise comparison
    *   FIXED_LEN_BYTE_ARRAY - unsigned byte-wise comparison
    *
-   * (*) Because the sorting order is not specified properly for floating
-   *     point values (relations vs. total ordering) the following
+   * (+) While the INT96 type has been deprecated, at the time of writing it is
+   *     still used in many legacy systems. It is optional for writers to emit
+   *     statistics for INT96 columns. Writers that emit stats for such columns
+   *     should use the INT96_TIMESTAMP_ORDER for this type and order the values
+   *     according to the legacy rules:
+   *     - compare the last 4 bytes (days) as a little-endian 32-bit signed integer
+   *     - if equal last 4 bytes, compare the first 8 bytes as a little-endian
+   *       64-bit signed integer (nanos)
+   *     If TYPE_ORDER is used for an INT96 column, readers should ignore all statistics
+   *     (`min`/`max` fields in `Statistics` and `min_values`/`max_values` fields in
+   *     `ColumnIndex`) for that column.
+   *
+   * (*) Because TYPE_ORDER is ambiguous for floating point types due to
+   *     underspecified handling of NaN and -0/+0, it is recommended that writers
+   *     use IEEE_754_TOTAL_ORDER for these types.
+   *
+   *     If TYPE_ORDER is used for floating point types, then the following
    *     compatibility rules should be applied when reading statistics:
    *     - If the min is a NaN, it should be ignored.
    *     - If the max is a NaN, it should be ignored.
+   *     - If the nan_count field is set, a reader can compute
+   *       nan_count + null_count == num_values to deduce whether all non-null
+   *       values are NaN.
    *     - If the min is +0, the row group may contain -0 values as well.
    *     - If the max is -0, the row group may contain +0 values as well.
    *     - When looking for NaN values, min and max should be ignored.
+   *       If the nan_count field is set, it can be used to check whether
+   *       NaNs are present.
    *
-   *     When writing statistics the following rules should be followed:
-   *     - NaNs should not be written to min or max statistics fields.
+   *     When writing page or column chunk statistics for columns with
+   *     TYPE_ORDER order, the following rules must be followed:
+   *     - The nan_count field must be set for floating point types, even if
+   *       it is zero.
+   *     - If the nan_count field is set, min and max statistics fields, when
+   *       present, must not contain NaN values and must be computed from
+   *       non-NaN values only. This signals to readers that the min and max
+   *       statistics are reliable for non-NaN values.
+   *     - If all non-null values are NaN, min and max statistics must not be
+   *       written.
    *     - If the computed max value is zero (whether negative or positive),
    *       `+0.0` should be written into the max statistics field.
    *     - If the computed min value is zero (whether negative or positive),
    *       `-0.0` should be written into the min statistics field.
+   *
+   *     When writing column indexes for columns with TYPE_ORDER order, the
+   *     following rules must be followed:
+   *     - NaNs must not be written to min_values or max_values.
+   *     - If all non-null values of a page are NaN, a column index must not
+   *       be written for this column chunk because min_values and max_values
+   *       are required.
+   *     - If the computed max value is zero (whether negative or positive),
+   *       `+0.0` should be written into the corresponding max_values entry.
+   *     - If the computed min value is zero (whether negative or positive),
+   *       `-0.0` should be written into the corresponding min_values entry.
    */
   1: TypeDefinedOrder TYPE_ORDER;
+
+  /*
+   * The floating point type is ordered according to the totalOrder predicate,
+   * as defined in section 5.10 of IEEE-754 (2008 revision). Only columns of
+   * physical type FLOAT or DOUBLE, or logical type FLOAT16 may use this ordering.
+   *
+   * Intuitively, this orders floats mathematically, but defines -0 to be less
+   * than +0, -NaN to be less than anything else, and +NaN to be greater than
+   * anything else. It also defines an order between different bit representations
+   * of the same value.
+   *
+   * When writing statistics for columns with IEEE_754_TOTAL_ORDER order, then
+   * following rules must be followed:
+   * - Writing the nan_count field is mandatory when using this ordering.
+   * - Min and max statistics must contain the smallest and largest non-NaN
+   *   values respectively, or if all non-null values are NaN, the smallest and
+   *   largest NaN values as defined by IEEE 754 total order.
+   *
+   * When reading statistics for columns with this order, the following rules
+   * should be followed:
+   * - Readers should consult the nan_count field to determine whether NaNs
+   *   are present.
+   * - A reader can compute nan_count + null_count == num_values to deduce
+   *   whether all non-null values are NaN. In the page index, which does not
+   *   have a num_values field, the presence of a NaN value in min_values
+   *   or max_values indicates that all non-null values are NaN.
+   */
+  2: IEEE754TotalOrder IEEE_754_TOTAL_ORDER;
+
+  /*
+   * The INT96 timestamp type is ordered chronologically. Only columns of
+   * physical type INT96 may use this ordering.
+   */
+  3: Int96TimestampOrder INT96_TIMESTAMP_ORDER;
 }
 
 struct PageLocation {
@@ -1016,8 +1238,8 @@ struct PageLocation {
   1: required i64 offset
 
   /**
-   * Size of the page, including header. Sum of compressed_page_size and header
-   * length
+   * Size of the page, including header. Equal to the sum of the page's
+   * PageHeader.compressed_page_size and the size of the serialized PageHeader.
    */
   2: required i32 compressed_page_size
 
@@ -1045,7 +1267,7 @@ struct OffsetIndex {
   /**
    * Unencoded/uncompressed size for BYTE_ARRAY types.
    *
-   * See documention for unencoded_byte_array_data_bytes in SizeStatistics for
+   * See documentation for unencoded_byte_array_data_bytes in SizeStatistics for
    * more details on this field.
    */
   2: optional list<i64> unencoded_byte_array_data_bytes
@@ -1075,11 +1297,30 @@ struct ColumnIndex {
    * Two lists containing lower and upper bounds for the values of each page
    * determined by the ColumnOrder of the column. These may be the actual
    * minimum and maximum values found on a page, but can also be (more compact)
-   * values that do not exist on a page. For example, instead of storing ""Blart
+   * values that do not exist on a page. For example, instead of storing "Blart
    * Versenwald III", a writer may set min_values[i]="B", max_values[i]="C".
    * Such more compact values must still be valid values within the column's
    * logical type. Readers must make sure that list entries are populated before
    * using them by inspecting null_pages.
+   *
+   * For columns of physical type FLOAT or DOUBLE, or logical type FLOAT16,
+   * NaN values are not to be included in these bounds. If all non-null values
+   * of a page are NaN, then a writer must do the following:
+   * - If the order of this column is TYPE_ORDER, then a column index must
+   *   not be written for this column chunk. While this is unfortunate for
+   *   performance, it is necessary to avoid conflict with legacy files that
+   *   still included NaN in min_values and max_values even if the page had
+   *   non-NaN values. To mitigate this, IEEE754_TOTAL_ORDER is recommended.
+   * - If the order of this column is IEEE754_TOTAL_ORDER, then min_values[i]
+   *   and max_values[i] of that page must be set to the smallest and largest
+   *   NaN values as defined by IEEE 754 total order.
+   *
+   * For columns of physical type INT96, the writer must do the following:
+   * - If the order of this column is not INT96_TIMESTAMP_ORDER, then a column
+   *   index must not be written for this column chunk.
+   * - If the order of this column is INT96_TIMESTAMP_ORDER, the min_values[i]
+   *   and max_values[i] of that page must be set to the smallest and largest
+   *   values as defined by the INT96 chronological timestamp ordering.
    */
   2: required list<binary> min_values
   3: required list<binary> max_values
@@ -1121,6 +1362,15 @@ struct ColumnIndex {
     * Same as repetition_level_histograms except for definitions levels.
     **/
    7: optional list<i64> definition_level_histograms;
+
+   /**
+    * A list containing the number of NaN values for each page. Only present
+    * for columns of physical type FLOAT or DOUBLE, or logical type FLOAT16.
+    * If this field is not present, readers MUST assume that there might be
+    * NaN values in any page.
+    */
+   8: optional list<i64> nan_counts
+
 }
 
 struct AesGcmV1 {
@@ -1156,7 +1406,14 @@ union EncryptionAlgorithm {
  * Description for file metadata
  */
 struct FileMetaData {
-  /** Version of this file **/
+  /** Version of this file
+    *
+    * As of December 2025, there is no agreed upon consensus of what constitutes
+    * version 2 of the file. For maximum compatibility with readers, writers should
+    * always populate "1" for version. For maximum compatibility with writers,
+    * readers should accept "1" and "2" interchangeably.  All other versions are
+    * reserved for potential future use-cases.
+    */
   1: required i32 version
 
   /** Parquet schema for this file.  This schema contains metadata for all the columns.
@@ -1186,7 +1443,7 @@ struct FileMetaData {
    * Sort order used for the min_value and max_value fields in the Statistics
    * objects and the min_values and max_values fields in the ColumnIndex
    * objects of each column in this file. Sort orders are listed in the order
-   * matching the columns in the schema. The indexes are not necessary the same
+   * matching the columns in the schema. The indexes are not necessarily the same
    * though, because only leaf nodes of the schema are represented in the list
    * of sort orders.
    *
@@ -1226,4 +1483,4 @@ struct FileCryptoMetaData {
   /** Retrieval metadata of key used for encryption of footer,
    *  and (possibly) columns **/
   2: optional binary key_metadata
-}
\ No newline at end of file
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Thrift/CompactProtocol.php b/src/lib/parquet/src/Flow/Parquet/Thrift/CompactProtocol.php
index 9d63627ae8..b6b83e56c2 100644
--- a/src/lib/parquet/src/Flow/Parquet/Thrift/CompactProtocol.php
+++ b/src/lib/parquet/src/Flow/Parquet/Thrift/CompactProtocol.php
@@ -137,7 +137,12 @@ public function getTransport(): Transport
 
     public function getTType(int $byte): int
     {
-        return self::$ttypes[$byte & 0x0F];
+        return (
+            self::$ttypes[$byte & 0x0F] ?? throw new TProtocolException(
+                'Unknown compact type ' . ($byte & 0x0F),
+                TProtocolException::INVALID_DATA,
+            )
+        );
     }
 
     public function getVarint(int $data): string
@@ -158,7 +163,7 @@ public function getVarint(int $data): string
     }
 
     /**
-     * @param-out bool|int $bool
+     * @param-out bool $bool
      */
     public function readBool(&$bool): int
     {
@@ -169,7 +174,12 @@ public function readBool(&$bool): int
         }
 
         if ($this->state === self::STATE_CONTAINER_READ) {
-            return $this->readByte($bool);
+            // a container element is one byte: 1 is true, writers send false as 2 (Apache Thrift) or 0
+            $byte = 0;
+            $read = $this->readByte($byte);
+            $bool = $byte === self::COMPACT_TRUE;
+
+            return $read;
         }
 
         throw new TProtocolException('Invalid state in compact protocol');
@@ -671,7 +681,7 @@ public function writeBool($bool): int
         }
 
         if ($this->state === self::STATE_CONTAINER_WRITE) {
-            return $this->writeByte($bool ? 1 : 0);
+            return $this->writeByte($bool ? self::COMPACT_TRUE : self::COMPACT_FALSE);
         }
 
         throw new TProtocolException('Invalid state in compact protocol');
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmCtrV1.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmCtrV1.php
index 9b10490389..4641febfa4 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmCtrV1.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmCtrV1.php
@@ -1,61 +1,62 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class AesGcmCtrV1
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'aad_prefix',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'aad_file_unique',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'supply_aad_prefix',
             'isRequired' => false,
             'type' => TType::BOOL,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Unique file identifier part of AAD suffix *.
-     *
-     * @var string
+     * AAD prefix *
+     * 
+     * @var null|string
      */
-    public $aad_file_unique;
-
+    public $aad_prefix = null;
     /**
-     * AAD prefix *.
-     *
-     * @var string
+     * Unique file identifier part of AAD suffix *
+     * 
+     * @var null|string
      */
-    public $aad_prefix;
-
+    public $aad_file_unique = null;
     /**
      * In files encrypted with AAD prefix without storing it,
-     * readers must supply the prefix *.
-     *
-     * @var bool
+     * readers must supply the prefix *
+     * 
+     * @var null|bool
      */
-    public $supply_aad_prefix;
+    public $supply_aad_prefix = null;
 
     public function __construct($vals = null)
     {
@@ -63,11 +64,9 @@ public function __construct($vals = null)
             if (isset($vals['aad_prefix'])) {
                 $this->aad_prefix = $vals['aad_prefix'];
             }
-
             if (isset($vals['aad_file_unique'])) {
                 $this->aad_file_unique = $vals['aad_file_unique'];
             }
-
             if (isset($vals['supply_aad_prefix'])) {
                 $this->supply_aad_prefix = $vals['supply_aad_prefix'];
             }
@@ -79,6 +78,7 @@ public function getName()
         return 'AesGcmCtrV1';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -86,14 +86,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRING) {
@@ -101,7 +98,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRING) {
@@ -109,7 +105,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::BOOL) {
@@ -117,18 +112,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -136,19 +127,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('AesGcmCtrV1');
-
         if ($this->aad_prefix !== null) {
             $xfer += $output->writeFieldBegin('aad_prefix', TType::STRING, 1);
             $xfer += $output->writeString($this->aad_prefix);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->aad_file_unique !== null) {
             $xfer += $output->writeFieldBegin('aad_file_unique', TType::STRING, 2);
             $xfer += $output->writeString($this->aad_file_unique);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->supply_aad_prefix !== null) {
             $xfer += $output->writeFieldBegin('supply_aad_prefix', TType::BOOL, 3);
             $xfer += $output->writeBool($this->supply_aad_prefix);
@@ -156,7 +144,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmV1.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmV1.php
index a34e9e1f33..8604b14a17 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmV1.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/AesGcmV1.php
@@ -1,61 +1,62 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class AesGcmV1
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'aad_prefix',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'aad_file_unique',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'supply_aad_prefix',
             'isRequired' => false,
             'type' => TType::BOOL,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Unique file identifier part of AAD suffix *.
-     *
-     * @var string
+     * AAD prefix *
+     * 
+     * @var null|string
      */
-    public $aad_file_unique;
-
+    public $aad_prefix = null;
     /**
-     * AAD prefix *.
-     *
-     * @var string
+     * Unique file identifier part of AAD suffix *
+     * 
+     * @var null|string
      */
-    public $aad_prefix;
-
+    public $aad_file_unique = null;
     /**
      * In files encrypted with AAD prefix without storing it,
-     * readers must supply the prefix *.
-     *
-     * @var bool
+     * readers must supply the prefix *
+     * 
+     * @var null|bool
      */
-    public $supply_aad_prefix;
+    public $supply_aad_prefix = null;
 
     public function __construct($vals = null)
     {
@@ -63,11 +64,9 @@ public function __construct($vals = null)
             if (isset($vals['aad_prefix'])) {
                 $this->aad_prefix = $vals['aad_prefix'];
             }
-
             if (isset($vals['aad_file_unique'])) {
                 $this->aad_file_unique = $vals['aad_file_unique'];
             }
-
             if (isset($vals['supply_aad_prefix'])) {
                 $this->supply_aad_prefix = $vals['supply_aad_prefix'];
             }
@@ -79,6 +78,7 @@ public function getName()
         return 'AesGcmV1';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -86,14 +86,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRING) {
@@ -101,7 +98,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRING) {
@@ -109,7 +105,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::BOOL) {
@@ -117,18 +112,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -136,19 +127,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('AesGcmV1');
-
         if ($this->aad_prefix !== null) {
             $xfer += $output->writeFieldBegin('aad_prefix', TType::STRING, 1);
             $xfer += $output->writeString($this->aad_prefix);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->aad_file_unique !== null) {
             $xfer += $output->writeFieldBegin('aad_file_unique', TType::STRING, 2);
             $xfer += $output->writeString($this->aad_file_unique);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->supply_aad_prefix !== null) {
             $xfer += $output->writeFieldBegin('supply_aad_prefix', TType::BOOL, 3);
             $xfer += $output->writeBool($this->supply_aad_prefix);
@@ -156,7 +144,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterAlgorithm.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterAlgorithm.php
index fc6898e195..9fb00cb4cb 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterAlgorithm.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterAlgorithm.php
@@ -1,41 +1,43 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * The algorithm used in Bloom filter. *.
+ * The algorithm used in Bloom filter. *
  */
 class BloomFilterAlgorithm
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'BLOCK',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\SplitBlockAlgorithm',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Block-based Bloom filter. *.
-     *
-     * @var SplitBlockAlgorithm
+     * Block-based Bloom filter. *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\SplitBlockAlgorithm
      */
-    public $BLOCK;
+    public $BLOCK = null;
 
     public function __construct($vals = null)
     {
@@ -51,6 +53,7 @@ public function getName()
         return 'BloomFilterAlgorithm';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -58,34 +61,27 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->BLOCK = new SplitBlockAlgorithm();
+                        $this->BLOCK = new \Flow\Parquet\ThriftModel\SplitBlockAlgorithm();
                         $xfer += $this->BLOCK->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -93,7 +89,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('BloomFilterAlgorithm');
-
         if ($this->BLOCK !== null) {
             if (!is_object($this->BLOCK)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -104,7 +99,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterCompression.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterCompression.php
index b19c25b750..d5b752f2d1 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterCompression.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterCompression.php
@@ -1,36 +1,38 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class BloomFilterCompression
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'UNCOMPRESSED',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\Uncompressed',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * @var Uncompressed
+     * @var null|\Flow\Parquet\ThriftModel\Uncompressed
      */
-    public $UNCOMPRESSED;
+    public $UNCOMPRESSED = null;
 
     public function __construct($vals = null)
     {
@@ -46,6 +48,7 @@ public function getName()
         return 'BloomFilterCompression';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -53,34 +56,27 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->UNCOMPRESSED = new Uncompressed();
+                        $this->UNCOMPRESSED = new \Flow\Parquet\ThriftModel\Uncompressed();
                         $xfer += $this->UNCOMPRESSED->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -88,7 +84,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('BloomFilterCompression');
-
         if ($this->UNCOMPRESSED !== null) {
             if (!is_object($this->UNCOMPRESSED)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -99,7 +94,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHash.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHash.php
index 1426be9ca5..e0fc796f9f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHash.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHash.php
@@ -1,42 +1,45 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * The hash function used in Bloom filter. This function takes the hash of a column value
  * using plain encoding.
+ * 
  */
 class BloomFilterHash
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'XXHASH',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\XxHash',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * xxHash Strategy. *.
-     *
-     * @var XxHash
+     * xxHash Strategy. *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\XxHash
      */
-    public $XXHASH;
+    public $XXHASH = null;
 
     public function __construct($vals = null)
     {
@@ -52,6 +55,7 @@ public function getName()
         return 'BloomFilterHash';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -59,34 +63,27 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->XXHASH = new XxHash();
+                        $this->XXHASH = new \Flow\Parquet\ThriftModel\XxHash();
                         $xfer += $this->XXHASH->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -94,7 +91,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('BloomFilterHash');
-
         if ($this->XXHASH !== null) {
             if (!is_object($this->XXHASH)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -105,7 +101,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHeader.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHeader.php
index 06682c552e..8d02039cd6 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BloomFilterHeader.php
@@ -1,80 +1,80 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Bloom filter header is stored at beginning of Bloom filter data of each column
  * and followed by its bitset.
+ * 
  */
 class BloomFilterHeader
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'numBytes',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'algorithm',
             'isRequired' => true,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\BloomFilterAlgorithm',
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'hash',
             'isRequired' => true,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\BloomFilterHash',
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'compression',
             'isRequired' => true,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\BloomFilterCompression',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * The algorithm for setting bits. *.
-     *
-     * @var BloomFilterAlgorithm
+     * The size of bitset in bytes *
+     * 
+     * @var int
      */
-    public $algorithm;
-
+    public $numBytes = null;
     /**
-     * The compression used in the Bloom filter *.
-     *
-     * @var BloomFilterCompression
+     * The algorithm for setting bits. *
+     * 
+     * @var \Flow\Parquet\ThriftModel\BloomFilterAlgorithm
      */
-    public $compression;
-
+    public $algorithm = null;
     /**
-     * The hash function used for Bloom filter. *.
-     *
-     * @var BloomFilterHash
+     * The hash function used for Bloom filter. *
+     * 
+     * @var \Flow\Parquet\ThriftModel\BloomFilterHash
      */
-    public $hash;
-
+    public $hash = null;
     /**
-     * The size of bitset in bytes *.
-     *
-     * @var int
+     * The compression used in the Bloom filter *
+     * 
+     * @var \Flow\Parquet\ThriftModel\BloomFilterCompression
      */
-    public $numBytes;
+    public $compression = null;
 
     public function __construct($vals = null)
     {
@@ -82,15 +82,12 @@ public function __construct($vals = null)
             if (isset($vals['numBytes'])) {
                 $this->numBytes = $vals['numBytes'];
             }
-
             if (isset($vals['algorithm'])) {
                 $this->algorithm = $vals['algorithm'];
             }
-
             if (isset($vals['hash'])) {
                 $this->hash = $vals['hash'];
             }
-
             if (isset($vals['compression'])) {
                 $this->compression = $vals['compression'];
             }
@@ -102,6 +99,7 @@ public function getName()
         return 'BloomFilterHeader';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -109,14 +107,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -124,45 +119,38 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->algorithm = new BloomFilterAlgorithm();
+                        $this->algorithm = new \Flow\Parquet\ThriftModel\BloomFilterAlgorithm();
                         $xfer += $this->algorithm->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::STRUCT) {
-                        $this->hash = new BloomFilterHash();
+                        $this->hash = new \Flow\Parquet\ThriftModel\BloomFilterHash();
                         $xfer += $this->hash->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::STRUCT) {
-                        $this->compression = new BloomFilterCompression();
+                        $this->compression = new \Flow\Parquet\ThriftModel\BloomFilterCompression();
                         $xfer += $this->compression->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -170,13 +158,11 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('BloomFilterHeader');
-
         if ($this->numBytes !== null) {
             $xfer += $output->writeFieldBegin('numBytes', TType::I32, 1);
             $xfer += $output->writeI32($this->numBytes);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->algorithm !== null) {
             if (!is_object($this->algorithm)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -185,7 +171,6 @@ public function write($output)
             $xfer += $this->algorithm->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->hash !== null) {
             if (!is_object($this->hash)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -194,7 +179,6 @@ public function write($output)
             $xfer += $this->hash->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->compression !== null) {
             if (!is_object($this->compression)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -205,7 +189,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundaryOrder.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundaryOrder.php
index 5982486ecb..5b9eba7519 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundaryOrder.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundaryOrder.php
@@ -1,31 +1,37 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 /**
  * Enum to annotate whether lists of min/max elements inside ColumnIndex
  * are ordered and if so, in which direction.
  */
 final class BoundaryOrder
 {
-    public const ASCENDING = 1;
+    const UNORDERED = 0;
 
-    public const DESCENDING = 2;
+    const ASCENDING = 1;
 
-    public const UNORDERED = 0;
+    const DESCENDING = 2;
 
-    public static $__names = [
+    static public $__names = array(
         0 => 'UNORDERED',
         1 => 'ASCENDING',
         2 => 'DESCENDING',
-    ];
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundingBox.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundingBox.php
new file mode 100644
index 0000000000..939d01127a
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BoundingBox.php
@@ -0,0 +1,266 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Bounding box for GEOMETRY or GEOGRAPHY type in the representation of min/max
+ * value pair of coordinates from each axis.
+ */
+class BoundingBox
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
+            'var' => 'xmin',
+            'isRequired' => true,
+            'type' => TType::DOUBLE,
+        ),
+        2 => array(
+            'var' => 'xmax',
+            'isRequired' => true,
+            'type' => TType::DOUBLE,
+        ),
+        3 => array(
+            'var' => 'ymin',
+            'isRequired' => true,
+            'type' => TType::DOUBLE,
+        ),
+        4 => array(
+            'var' => 'ymax',
+            'isRequired' => true,
+            'type' => TType::DOUBLE,
+        ),
+        5 => array(
+            'var' => 'zmin',
+            'isRequired' => false,
+            'type' => TType::DOUBLE,
+        ),
+        6 => array(
+            'var' => 'zmax',
+            'isRequired' => false,
+            'type' => TType::DOUBLE,
+        ),
+        7 => array(
+            'var' => 'mmin',
+            'isRequired' => false,
+            'type' => TType::DOUBLE,
+        ),
+        8 => array(
+            'var' => 'mmax',
+            'isRequired' => false,
+            'type' => TType::DOUBLE,
+        ),
+    );
+
+    /**
+     * @var double
+     */
+    public $xmin = null;
+    /**
+     * @var double
+     */
+    public $xmax = null;
+    /**
+     * @var double
+     */
+    public $ymin = null;
+    /**
+     * @var double
+     */
+    public $ymax = null;
+    /**
+     * @var null|double
+     */
+    public $zmin = null;
+    /**
+     * @var null|double
+     */
+    public $zmax = null;
+    /**
+     * @var null|double
+     */
+    public $mmin = null;
+    /**
+     * @var null|double
+     */
+    public $mmax = null;
+
+    public function __construct($vals = null)
+    {
+        if (is_array($vals)) {
+            if (isset($vals['xmin'])) {
+                $this->xmin = $vals['xmin'];
+            }
+            if (isset($vals['xmax'])) {
+                $this->xmax = $vals['xmax'];
+            }
+            if (isset($vals['ymin'])) {
+                $this->ymin = $vals['ymin'];
+            }
+            if (isset($vals['ymax'])) {
+                $this->ymax = $vals['ymax'];
+            }
+            if (isset($vals['zmin'])) {
+                $this->zmin = $vals['zmin'];
+            }
+            if (isset($vals['zmax'])) {
+                $this->zmax = $vals['zmax'];
+            }
+            if (isset($vals['mmin'])) {
+                $this->mmin = $vals['mmin'];
+            }
+            if (isset($vals['mmax'])) {
+                $this->mmax = $vals['mmax'];
+            }
+        }
+    }
+
+    public function getName()
+    {
+        return 'BoundingBox';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                case 1:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->xmin);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 2:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->xmax);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 3:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->ymin);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 4:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->ymax);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 5:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->zmin);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 6:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->zmax);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 7:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->mmin);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 8:
+                    if ($ftype == TType::DOUBLE) {
+                        $xfer += $input->readDouble($this->mmax);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('BoundingBox');
+        if ($this->xmin !== null) {
+            $xfer += $output->writeFieldBegin('xmin', TType::DOUBLE, 1);
+            $xfer += $output->writeDouble($this->xmin);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->xmax !== null) {
+            $xfer += $output->writeFieldBegin('xmax', TType::DOUBLE, 2);
+            $xfer += $output->writeDouble($this->xmax);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->ymin !== null) {
+            $xfer += $output->writeFieldBegin('ymin', TType::DOUBLE, 3);
+            $xfer += $output->writeDouble($this->ymin);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->ymax !== null) {
+            $xfer += $output->writeFieldBegin('ymax', TType::DOUBLE, 4);
+            $xfer += $output->writeDouble($this->ymax);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->zmin !== null) {
+            $xfer += $output->writeFieldBegin('zmin', TType::DOUBLE, 5);
+            $xfer += $output->writeDouble($this->zmin);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->zmax !== null) {
+            $xfer += $output->writeFieldBegin('zmax', TType::DOUBLE, 6);
+            $xfer += $output->writeDouble($this->zmax);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->mmin !== null) {
+            $xfer += $output->writeFieldBegin('mmin', TType::DOUBLE, 7);
+            $xfer += $output->writeDouble($this->mmin);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->mmax !== null) {
+            $xfer += $output->writeFieldBegin('mmax', TType::DOUBLE, 8);
+            $xfer += $output->writeDouble($this->mmax);
+            $xfer += $output->writeFieldEnd();
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BsonType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BsonType.php
index 108a26cc7c..1f692b351e 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/BsonType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/BsonType.php
@@ -1,36 +1,44 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Embedded BSON logical type annotation.
- *
+ * Embedded BSON logical type annotation
+ * 
  * Allowed for physical types: BYTE_ARRAY
  */
 class BsonType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'BsonType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -38,24 +46,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -65,7 +68,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('BsonType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnChunk.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnChunk.php
index bb1efef2e1..f55ae97f4f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnChunk.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnChunk.php
@@ -1,146 +1,157 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class ColumnChunk
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'file_path',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'file_offset',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'meta_data',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\ColumnMetaData',
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'offset_index_offset',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'offset_index_length',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'column_index_offset',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'column_index_length',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'crypto_metadata',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\ColumnCryptoMetaData',
-        ],
-        9 => [
+        ),
+        9 => array(
             'var' => 'encrypted_column_metadata',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Size of ColumnChunk's ColumnIndex, in bytes *.
-     *
-     * @var int
-     */
-    public $column_index_length;
-
-    /**
-     * File offset of ColumnChunk's ColumnIndex *.
-     *
-     * @var int
-     */
-    public $column_index_offset;
-
-    /**
-     * Crypto metadata of encrypted columns *.
-     *
-     * @var ColumnCryptoMetaData
-     */
-    public $crypto_metadata;
-
-    /**
-     * Encrypted column metadata for this chunk *.
-     *
-     * @var string
+     * File where column data is stored.  If not set, assumed to be same file as
+     * metadata.  This path is relative to the current file.
+     * 
+     * As of December 2025, the only known use-case for this field is writing summary
+     * parquet files (i.e. "_metadata" files).  These files consolidate footers from
+     * multiple parquet files to allow for efficient reading of footers to avoid file
+     * listing costs and prune out files that do not need to be read based on statistics.
+     * 
+     * These files do not appear to have ever been formally specified in the specification.
+     * and are potentially problematic from a correctness perspective [1].
+     * 
+     * [1] https://lists.apache.org/thread/ootf2kmyg3p01b1bvplpvp4ftd1bt72d
+     * 
+     * There is no other known usage of this field. Specifically, there are no known
+     * reference implementations that will read externally stored column data if this field is populated
+     * within a standard parquet file. Making use of the field for this purpose is
+     * not considered part of the Parquet specification.
+     * 
+     * 
+     * @var null|string
      */
-    public $encrypted_column_metadata;
-
+    public $file_path = null;
     /**
-     * Deprecated: Byte offset in file_path to the ColumnMetaData.
-     *
+     * DEPRECATED: Byte offset in file_path to the ColumnMetaData
+     * 
      * Past use of this field has been inconsistent, with some implementations
      * using it to point to the ColumnMetaData and some using it to point to
      * the first page in the column chunk. In many cases, the ColumnMetaData at this
      * location is wrong. This field is now deprecated and should not be used.
      * Writers should set this field to 0 if no ColumnMetaData has been written outside
      * the footer.
-     *
+     * 
      * @var int
      */
     public $file_offset = 0;
-
-    /**
-     * File where column data is stored.  If not set, assumed to be same file as
-     * metadata.  This path is relative to the current file.
-     *
-     * @var string
-     */
-    public $file_path;
-
     /**
      * Column metadata for this chunk. Some writers may also replicate this at the
      * location pointed to by file_path/file_offset.
      * Note: while marked as optional, this field is in fact required by most major
      * Parquet implementations. As such, writers MUST populate this field.
-     *
-     * @var ColumnMetaData
+     * 
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\ColumnMetaData
      */
-    public $meta_data;
-
+    public $meta_data = null;
     /**
-     * Size of ColumnChunk's OffsetIndex, in bytes *.
-     *
-     * @var int
+     * File offset of ColumnChunk's OffsetIndex *
+     * 
+     * @var null|int
      */
-    public $offset_index_length;
-
+    public $offset_index_offset = null;
     /**
-     * File offset of ColumnChunk's OffsetIndex *.
-     *
-     * @var int
+     * Size of ColumnChunk's OffsetIndex, in bytes *
+     * 
+     * @var null|int
+     */
+    public $offset_index_length = null;
+    /**
+     * File offset of ColumnChunk's ColumnIndex *
+     * 
+     * @var null|int
+     */
+    public $column_index_offset = null;
+    /**
+     * Size of ColumnChunk's ColumnIndex, in bytes *
+     * 
+     * @var null|int
+     */
+    public $column_index_length = null;
+    /**
+     * Crypto metadata of encrypted columns *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\ColumnCryptoMetaData
      */
-    public $offset_index_offset;
+    public $crypto_metadata = null;
+    /**
+     * Encrypted column metadata for this chunk *
+     * 
+     * @var null|string
+     */
+    public $encrypted_column_metadata = null;
 
     public function __construct($vals = null)
     {
@@ -148,35 +159,27 @@ public function __construct($vals = null)
             if (isset($vals['file_path'])) {
                 $this->file_path = $vals['file_path'];
             }
-
             if (isset($vals['file_offset'])) {
                 $this->file_offset = $vals['file_offset'];
             }
-
             if (isset($vals['meta_data'])) {
                 $this->meta_data = $vals['meta_data'];
             }
-
             if (isset($vals['offset_index_offset'])) {
                 $this->offset_index_offset = $vals['offset_index_offset'];
             }
-
             if (isset($vals['offset_index_length'])) {
                 $this->offset_index_length = $vals['offset_index_length'];
             }
-
             if (isset($vals['column_index_offset'])) {
                 $this->column_index_offset = $vals['column_index_offset'];
             }
-
             if (isset($vals['column_index_length'])) {
                 $this->column_index_length = $vals['column_index_length'];
             }
-
             if (isset($vals['crypto_metadata'])) {
                 $this->crypto_metadata = $vals['crypto_metadata'];
             }
-
             if (isset($vals['encrypted_column_metadata'])) {
                 $this->encrypted_column_metadata = $vals['encrypted_column_metadata'];
             }
@@ -188,6 +191,7 @@ public function getName()
         return 'ColumnChunk';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -195,14 +199,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRING) {
@@ -210,7 +211,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I64) {
@@ -218,16 +218,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::STRUCT) {
-                        $this->meta_data = new ColumnMetaData();
+                        $this->meta_data = new \Flow\Parquet\ThriftModel\ColumnMetaData();
                         $xfer += $this->meta_data->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I64) {
@@ -235,7 +233,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::I32) {
@@ -243,7 +240,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::I64) {
@@ -251,7 +247,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::I32) {
@@ -259,16 +254,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::STRUCT) {
-                        $this->crypto_metadata = new ColumnCryptoMetaData();
+                        $this->crypto_metadata = new \Flow\Parquet\ThriftModel\ColumnCryptoMetaData();
                         $xfer += $this->crypto_metadata->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 9:
                     if ($ftype == TType::STRING) {
@@ -276,18 +269,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -295,19 +284,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('ColumnChunk');
-
         if ($this->file_path !== null) {
             $xfer += $output->writeFieldBegin('file_path', TType::STRING, 1);
             $xfer += $output->writeString($this->file_path);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->file_offset !== null) {
             $xfer += $output->writeFieldBegin('file_offset', TType::I64, 2);
             $xfer += $output->writeI64($this->file_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->meta_data !== null) {
             if (!is_object($this->meta_data)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -316,31 +302,26 @@ public function write($output)
             $xfer += $this->meta_data->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->offset_index_offset !== null) {
             $xfer += $output->writeFieldBegin('offset_index_offset', TType::I64, 4);
             $xfer += $output->writeI64($this->offset_index_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->offset_index_length !== null) {
             $xfer += $output->writeFieldBegin('offset_index_length', TType::I32, 5);
             $xfer += $output->writeI32($this->offset_index_length);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->column_index_offset !== null) {
             $xfer += $output->writeFieldBegin('column_index_offset', TType::I64, 6);
             $xfer += $output->writeI64($this->column_index_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->column_index_length !== null) {
             $xfer += $output->writeFieldBegin('column_index_length', TType::I32, 7);
             $xfer += $output->writeI32($this->column_index_length);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->crypto_metadata !== null) {
             if (!is_object($this->crypto_metadata)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -349,7 +330,6 @@ public function write($output)
             $xfer += $this->crypto_metadata->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encrypted_column_metadata !== null) {
             $xfer += $output->writeFieldBegin('encrypted_column_metadata', TType::STRING, 9);
             $xfer += $output->writeString($this->encrypted_column_metadata);
@@ -357,7 +337,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnCryptoMetaData.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnCryptoMetaData.php
index cf578e9f76..4356a5c553 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnCryptoMetaData.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnCryptoMetaData.php
@@ -1,47 +1,48 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class ColumnCryptoMetaData
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'ENCRYPTION_WITH_FOOTER_KEY',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\EncryptionWithFooterKey',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'ENCRYPTION_WITH_COLUMN_KEY',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\EncryptionWithColumnKey',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * @var EncryptionWithColumnKey
+     * @var null|\Flow\Parquet\ThriftModel\EncryptionWithFooterKey
      */
-    public $ENCRYPTION_WITH_COLUMN_KEY;
-
+    public $ENCRYPTION_WITH_FOOTER_KEY = null;
     /**
-     * @var EncryptionWithFooterKey
+     * @var null|\Flow\Parquet\ThriftModel\EncryptionWithColumnKey
      */
-    public $ENCRYPTION_WITH_FOOTER_KEY;
+    public $ENCRYPTION_WITH_COLUMN_KEY = null;
 
     public function __construct($vals = null)
     {
@@ -49,7 +50,6 @@ public function __construct($vals = null)
             if (isset($vals['ENCRYPTION_WITH_FOOTER_KEY'])) {
                 $this->ENCRYPTION_WITH_FOOTER_KEY = $vals['ENCRYPTION_WITH_FOOTER_KEY'];
             }
-
             if (isset($vals['ENCRYPTION_WITH_COLUMN_KEY'])) {
                 $this->ENCRYPTION_WITH_COLUMN_KEY = $vals['ENCRYPTION_WITH_COLUMN_KEY'];
             }
@@ -61,6 +61,7 @@ public function getName()
         return 'ColumnCryptoMetaData';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -68,43 +69,35 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->ENCRYPTION_WITH_FOOTER_KEY = new EncryptionWithFooterKey();
+                        $this->ENCRYPTION_WITH_FOOTER_KEY = new \Flow\Parquet\ThriftModel\EncryptionWithFooterKey();
                         $xfer += $this->ENCRYPTION_WITH_FOOTER_KEY->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->ENCRYPTION_WITH_COLUMN_KEY = new EncryptionWithColumnKey();
+                        $this->ENCRYPTION_WITH_COLUMN_KEY = new \Flow\Parquet\ThriftModel\EncryptionWithColumnKey();
                         $xfer += $this->ENCRYPTION_WITH_COLUMN_KEY->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -112,7 +105,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('ColumnCryptoMetaData');
-
         if ($this->ENCRYPTION_WITH_FOOTER_KEY !== null) {
             if (!is_object($this->ENCRYPTION_WITH_FOOTER_KEY)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -121,7 +113,6 @@ public function write($output)
             $xfer += $this->ENCRYPTION_WITH_FOOTER_KEY->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->ENCRYPTION_WITH_COLUMN_KEY !== null) {
             if (!is_object($this->ENCRYPTION_WITH_COLUMN_KEY)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -132,7 +123,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnIndex.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnIndex.php
index 2a962e08d1..7d4ebcc9ab 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnIndex.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnIndex.php
@@ -1,172 +1,207 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Optional statistics for each data page in a ColumnChunk.
- *
+ * 
  * Forms part the page index, along with OffsetIndex.
- *
+ * 
  * If this structure is present, OffsetIndex must also be present.
- *
+ * 
  * For each field in this structure, <field>[i] refers to the page at
  * OffsetIndex.page_locations[i]
  */
 class ColumnIndex
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'null_pages',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::BOOL,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::BOOL,
-            ],
-        ],
-        2 => [
+                ),
+        ),
+        2 => array(
             'var' => 'min_values',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRING,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRING,
-            ],
-        ],
-        3 => [
+                ),
+        ),
+        3 => array(
             'var' => 'max_values',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRING,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRING,
-            ],
-        ],
-        4 => [
+                ),
+        ),
+        4 => array(
             'var' => 'boundary_order',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\BoundaryOrder',
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'null_counts',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::I64,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I64,
-            ],
-        ],
-        6 => [
+                ),
+        ),
+        6 => array(
             'var' => 'repetition_level_histograms',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::I64,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I64,
-            ],
-        ],
-        7 => [
+                ),
+        ),
+        7 => array(
             'var' => 'definition_level_histograms',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::I64,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I64,
-            ],
-        ],
-    ];
-
-    public static $isValidate = false;
-
-    /**
-     * Stores whether both min_values and max_values are ordered and if so, in
-     * which direction. This allows readers to perform binary searches in both
-     * lists. Readers cannot assume that max_values[i] <= min_values[i+1], even
-     * if the lists are ordered.
-     *
-     * @var int
-     */
-    public $boundary_order;
-
-    /**
-     * Same as repetition_level_histograms except for definitions levels.
-     *
-     * @var array<int>
-     */
-    public $definition_level_histograms;
+                ),
+        ),
+        8 => array(
+            'var' => 'nan_counts',
+            'isRequired' => false,
+            'type' => TType::LST,
+            'etype' => TType::I64,
+            'elem' => array(
+                'type' => TType::I64,
+                ),
+        ),
+    );
 
     /**
-     * @var array<string>
+     * A list of Boolean values to determine the validity of the corresponding
+     * min and max values. If true, a page contains only null values, and writers
+     * have to set the corresponding entries in min_values and max_values to
+     * byte[0], so that all lists have the same length. If false, the
+     * corresponding entries in min_values and max_values must be valid.
+     * 
+     * @var bool[]
      */
-    public $max_values;
-
+    public $null_pages = null;
     /**
      * Two lists containing lower and upper bounds for the values of each page
      * determined by the ColumnOrder of the column. These may be the actual
      * minimum and maximum values found on a page, but can also be (more compact)
-     * values that do not exist on a page. For example, instead of storing ""Blart
+     * values that do not exist on a page. For example, instead of storing "Blart
      * Versenwald III", a writer may set min_values[i]="B", max_values[i]="C".
      * Such more compact values must still be valid values within the column's
      * logical type. Readers must make sure that list entries are populated before
      * using them by inspecting null_pages.
-     *
-     * @var array<string>
+     * 
+     * For columns of physical type FLOAT or DOUBLE, or logical type FLOAT16,
+     * NaN values are not to be included in these bounds. If all non-null values
+     * of a page are NaN, then a writer must do the following:
+     * - If the order of this column is TYPE_ORDER, then a column index must
+     *   not be written for this column chunk. While this is unfortunate for
+     *   performance, it is necessary to avoid conflict with legacy files that
+     *   still included NaN in min_values and max_values even if the page had
+     *   non-NaN values. To mitigate this, IEEE754_TOTAL_ORDER is recommended.
+     * - If the order of this column is IEEE754_TOTAL_ORDER, then min_values[i]
+     *   and max_values[i] of that page must be set to the smallest and largest
+     *   NaN values as defined by IEEE 754 total order.
+     * 
+     * For columns of physical type INT96, the writer must do the following:
+     * - If the order of this column is not INT96_TIMESTAMP_ORDER, then a column
+     *   index must not be written for this column chunk.
+     * - If the order of this column is INT96_TIMESTAMP_ORDER, the min_values[i]
+     *   and max_values[i] of that page must be set to the smallest and largest
+     *   values as defined by the INT96 chronological timestamp ordering.
+     * 
+     * @var string[]
      */
-    public $min_values;
-
+    public $min_values = null;
+    /**
+     * @var string[]
+     */
+    public $max_values = null;
+    /**
+     * Stores whether both min_values and max_values are ordered and if so, in
+     * which direction. This allows readers to perform binary searches in both
+     * lists. Readers cannot assume that max_values[i] <= min_values[i+1], even
+     * if the lists are ordered.
+     * 
+     * @var int
+     */
+    public $boundary_order = null;
     /**
-     * A list containing the number of null values for each page.
-     *
+     * A list containing the number of null values for each page
+     * 
      * Writers SHOULD always write this field even if no null values
      * are present or the column is not nullable.
      * Readers MUST distinguish between null_counts not being present
      * and null_count being 0.
      * If null_counts are not present, readers MUST NOT assume all
      * null counts are 0.
-     *
-     * @var array<int>
+     * 
+     * @var null|int[]
      */
-    public $null_counts;
-
-    /**
-     * A list of Boolean values to determine the validity of the corresponding
-     * min and max values. If true, a page contains only null values, and writers
-     * have to set the corresponding entries in min_values and max_values to
-     * byte[0], so that all lists have the same length. If false, the
-     * corresponding entries in min_values and max_values must be valid.
-     *
-     * @var array<bool>
-     */
-    public $null_pages;
-
+    public $null_counts = null;
     /**
      * Contains repetition level histograms for each page
      * concatenated together.  The repetition_level_histogram field on
      * SizeStatistics contains more details.
-     *
+     * 
      * When present the length should always be (number of pages *
      * (max_repetition_level + 1)) elements.
-     *
+     * 
      * Element 0 is the first element of the histogram for the first page.
      * Element (max_repetition_level + 1) is the first element of the histogram
      * for the second page.
-     *
-     * @var array<int>
+     * 
+     * 
+     * @var null|int[]
+     */
+    public $repetition_level_histograms = null;
+    /**
+     * Same as repetition_level_histograms except for definitions levels.
+     * 
+     * 
+     * @var null|int[]
+     */
+    public $definition_level_histograms = null;
+    /**
+     * A list containing the number of NaN values for each page. Only present
+     * for columns of physical type FLOAT or DOUBLE, or logical type FLOAT16.
+     * If this field is not present, readers MUST assume that there might be
+     * NaN values in any page.
+     * 
+     * @var null|int[]
      */
-    public $repetition_level_histograms;
+    public $nan_counts = null;
 
     public function __construct($vals = null)
     {
@@ -174,30 +209,27 @@ public function __construct($vals = null)
             if (isset($vals['null_pages'])) {
                 $this->null_pages = $vals['null_pages'];
             }
-
             if (isset($vals['min_values'])) {
                 $this->min_values = $vals['min_values'];
             }
-
             if (isset($vals['max_values'])) {
                 $this->max_values = $vals['max_values'];
             }
-
             if (isset($vals['boundary_order'])) {
                 $this->boundary_order = $vals['boundary_order'];
             }
-
             if (isset($vals['null_counts'])) {
                 $this->null_counts = $vals['null_counts'];
             }
-
             if (isset($vals['repetition_level_histograms'])) {
                 $this->repetition_level_histograms = $vals['repetition_level_histograms'];
             }
-
             if (isset($vals['definition_level_histograms'])) {
                 $this->definition_level_histograms = $vals['definition_level_histograms'];
             }
+            if (isset($vals['nan_counts'])) {
+                $this->nan_counts = $vals['nan_counts'];
+            }
         }
     }
 
@@ -206,6 +238,7 @@ public function getName()
         return 'ColumnIndex';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -213,68 +246,59 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::LST) {
-                        $this->null_pages = [];
-                        $_size77 = 0;
-                        $_etype80 = 0;
-                        $xfer += $input->readListBegin($_etype80, $_size77);
-
-                        for ($_i81 = 0; $_i81 < $_size77; $_i81++) {
-                            $elem82 = null;
-                            $xfer += $input->readBool($elem82);
-                            $this->null_pages[] = $elem82;
+                        $this->null_pages = array();
+                        $_size84 = 0;
+                        $_etype87 = 0;
+                        $xfer += $input->readListBegin($_etype87, $_size84);
+                        for ($_i88 = 0; $_i88 < $_size84; ++$_i88) {
+                            $elem89 = null;
+                            $xfer += $input->readBool($elem89);
+                            $this->null_pages []= $elem89;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::LST) {
-                        $this->min_values = [];
-                        $_size83 = 0;
-                        $_etype86 = 0;
-                        $xfer += $input->readListBegin($_etype86, $_size83);
-
-                        for ($_i87 = 0; $_i87 < $_size83; $_i87++) {
-                            $elem88 = null;
-                            $xfer += $input->readString($elem88);
-                            $this->min_values[] = $elem88;
+                        $this->min_values = array();
+                        $_size90 = 0;
+                        $_etype93 = 0;
+                        $xfer += $input->readListBegin($_etype93, $_size90);
+                        for ($_i94 = 0; $_i94 < $_size90; ++$_i94) {
+                            $elem95 = null;
+                            $xfer += $input->readString($elem95);
+                            $this->min_values []= $elem95;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::LST) {
-                        $this->max_values = [];
-                        $_size89 = 0;
-                        $_etype92 = 0;
-                        $xfer += $input->readListBegin($_etype92, $_size89);
-
-                        for ($_i93 = 0; $_i93 < $_size89; $_i93++) {
-                            $elem94 = null;
-                            $xfer += $input->readString($elem94);
-                            $this->max_values[] = $elem94;
+                        $this->max_values = array();
+                        $_size96 = 0;
+                        $_etype99 = 0;
+                        $xfer += $input->readListBegin($_etype99, $_size96);
+                        for ($_i100 = 0; $_i100 < $_size96; ++$_i100) {
+                            $elem101 = null;
+                            $xfer += $input->readString($elem101);
+                            $this->max_values []= $elem101;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I32) {
@@ -282,72 +306,78 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::LST) {
-                        $this->null_counts = [];
-                        $_size95 = 0;
-                        $_etype98 = 0;
-                        $xfer += $input->readListBegin($_etype98, $_size95);
-
-                        for ($_i99 = 0; $_i99 < $_size95; $_i99++) {
-                            $elem100 = null;
-                            $xfer += $input->readI64($elem100);
-                            $this->null_counts[] = $elem100;
+                        $this->null_counts = array();
+                        $_size102 = 0;
+                        $_etype105 = 0;
+                        $xfer += $input->readListBegin($_etype105, $_size102);
+                        for ($_i106 = 0; $_i106 < $_size102; ++$_i106) {
+                            $elem107 = null;
+                            $xfer += $input->readI64($elem107);
+                            $this->null_counts []= $elem107;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::LST) {
-                        $this->repetition_level_histograms = [];
-                        $_size101 = 0;
-                        $_etype104 = 0;
-                        $xfer += $input->readListBegin($_etype104, $_size101);
-
-                        for ($_i105 = 0; $_i105 < $_size101; $_i105++) {
-                            $elem106 = null;
-                            $xfer += $input->readI64($elem106);
-                            $this->repetition_level_histograms[] = $elem106;
+                        $this->repetition_level_histograms = array();
+                        $_size108 = 0;
+                        $_etype111 = 0;
+                        $xfer += $input->readListBegin($_etype111, $_size108);
+                        for ($_i112 = 0; $_i112 < $_size108; ++$_i112) {
+                            $elem113 = null;
+                            $xfer += $input->readI64($elem113);
+                            $this->repetition_level_histograms []= $elem113;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::LST) {
-                        $this->definition_level_histograms = [];
-                        $_size107 = 0;
-                        $_etype110 = 0;
-                        $xfer += $input->readListBegin($_etype110, $_size107);
-
-                        for ($_i111 = 0; $_i111 < $_size107; $_i111++) {
-                            $elem112 = null;
-                            $xfer += $input->readI64($elem112);
-                            $this->definition_level_histograms[] = $elem112;
+                        $this->definition_level_histograms = array();
+                        $_size114 = 0;
+                        $_etype117 = 0;
+                        $xfer += $input->readListBegin($_etype117, $_size114);
+                        for ($_i118 = 0; $_i118 < $_size114; ++$_i118) {
+                            $elem119 = null;
+                            $xfer += $input->readI64($elem119);
+                            $this->definition_level_histograms []= $elem119;
+                        }
+                        $xfer += $input->readListEnd();
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 8:
+                    if ($ftype == TType::LST) {
+                        $this->nan_counts = array();
+                        $_size120 = 0;
+                        $_etype123 = 0;
+                        $xfer += $input->readListBegin($_etype123, $_size120);
+                        for ($_i124 = 0; $_i124 < $_size120; ++$_i124) {
+                            $elem125 = null;
+                            $xfer += $input->readI64($elem125);
+                            $this->nan_counts []= $elem125;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -355,99 +385,97 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('ColumnIndex');
-
         if ($this->null_pages !== null) {
             if (!is_array($this->null_pages)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('null_pages', TType::LST, 1);
             $output->writeListBegin(TType::BOOL, count($this->null_pages));
-
-            foreach ($this->null_pages as $iter113) {
-                $xfer += $output->writeBool($iter113);
+            foreach ($this->null_pages as $iter126) {
+                $xfer += $output->writeBool($iter126);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->min_values !== null) {
             if (!is_array($this->min_values)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('min_values', TType::LST, 2);
             $output->writeListBegin(TType::STRING, count($this->min_values));
-
-            foreach ($this->min_values as $iter114) {
-                $xfer += $output->writeString($iter114);
+            foreach ($this->min_values as $iter127) {
+                $xfer += $output->writeString($iter127);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->max_values !== null) {
             if (!is_array($this->max_values)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('max_values', TType::LST, 3);
             $output->writeListBegin(TType::STRING, count($this->max_values));
-
-            foreach ($this->max_values as $iter115) {
-                $xfer += $output->writeString($iter115);
+            foreach ($this->max_values as $iter128) {
+                $xfer += $output->writeString($iter128);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->boundary_order !== null) {
             $xfer += $output->writeFieldBegin('boundary_order', TType::I32, 4);
             $xfer += $output->writeI32($this->boundary_order);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->null_counts !== null) {
             if (!is_array($this->null_counts)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('null_counts', TType::LST, 5);
             $output->writeListBegin(TType::I64, count($this->null_counts));
-
-            foreach ($this->null_counts as $iter116) {
-                $xfer += $output->writeI64($iter116);
+            foreach ($this->null_counts as $iter129) {
+                $xfer += $output->writeI64($iter129);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->repetition_level_histograms !== null) {
             if (!is_array($this->repetition_level_histograms)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('repetition_level_histograms', TType::LST, 6);
             $output->writeListBegin(TType::I64, count($this->repetition_level_histograms));
-
-            foreach ($this->repetition_level_histograms as $iter117) {
-                $xfer += $output->writeI64($iter117);
+            foreach ($this->repetition_level_histograms as $iter130) {
+                $xfer += $output->writeI64($iter130);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->definition_level_histograms !== null) {
             if (!is_array($this->definition_level_histograms)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('definition_level_histograms', TType::LST, 7);
             $output->writeListBegin(TType::I64, count($this->definition_level_histograms));
-
-            foreach ($this->definition_level_histograms as $iter118) {
-                $xfer += $output->writeI64($iter118);
+            foreach ($this->definition_level_histograms as $iter131) {
+                $xfer += $output->writeI64($iter131);
+            }
+            $output->writeListEnd();
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->nan_counts !== null) {
+            if (!is_array($this->nan_counts)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('nan_counts', TType::LST, 8);
+            $output->writeListBegin(TType::I64, count($this->nan_counts));
+            foreach ($this->nan_counts as $iter132) {
+                $xfer += $output->writeI64($iter132);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnMetaData.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnMetaData.php
index 438c05118c..1bad68c126 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnMetaData.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnMetaData.php
@@ -1,254 +1,253 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Description for column metadata.
+ * Description for column metadata
  */
 class ColumnMetaData
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'type',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Type',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'encodings',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::I32,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I32,
                 'class' => '\Flow\Parquet\ThriftModel\Encoding',
-            ],
-        ],
-        3 => [
+                ),
+        ),
+        3 => array(
             'var' => 'path_in_schema',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRING,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRING,
-            ],
-        ],
-        4 => [
+                ),
+        ),
+        4 => array(
             'var' => 'codec',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\CompressionCodec',
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'num_values',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'total_uncompressed_size',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'total_compressed_size',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'key_value_metadata',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\KeyValue',
-            ],
-        ],
-        9 => [
+                ),
+        ),
+        9 => array(
             'var' => 'data_page_offset',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        10 => [
+        ),
+        10 => array(
             'var' => 'index_page_offset',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        11 => [
+        ),
+        11 => array(
             'var' => 'dictionary_page_offset',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        12 => [
+        ),
+        12 => array(
             'var' => 'statistics',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\Statistics',
-        ],
-        13 => [
+        ),
+        13 => array(
             'var' => 'encoding_stats',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\PageEncodingStats',
-            ],
-        ],
-        14 => [
+                ),
+        ),
+        14 => array(
             'var' => 'bloom_filter_offset',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        15 => [
+        ),
+        15 => array(
             'var' => 'bloom_filter_length',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        16 => [
+        ),
+        16 => array(
             'var' => 'size_statistics',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\SizeStatistics',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+        17 => array(
+            'var' => 'geospatial_statistics',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\GeospatialStatistics',
+        ),
+    );
 
     /**
-     * Size of Bloom filter data including the serialized header, in bytes.
-     * Added in 2.10 so readers may not read this field from old files and
-     * it can be obtained after the BloomFilterHeader has been deserialized.
-     * Writers should write this field so readers can read the bloom filter
-     * in a single I/O.
-     *
+     * Type of this column *
+     * 
      * @var int
      */
-    public $bloom_filter_length;
-
+    public $type = null;
     /**
-     * Byte offset from beginning of file to Bloom filter data. *.
-     *
-     * @var int
+     * Set of all encodings used for this column. The purpose is to validate
+     * whether we can decode those pages. *
+     * 
+     * @var int[]
      */
-    public $bloom_filter_offset;
-
+    public $encodings = null;
+    /**
+     * Path in schema *
+     * 
+     * @var string[]
+     */
+    public $path_in_schema = null;
     /**
-     * Compression codec *.
-     *
+     * Compression codec *
+     * 
      * @var int
      */
-    public $codec;
-
+    public $codec = null;
     /**
-     * Byte offset from beginning of file to first data page *.
-     *
+     * Number of values in this column *
+     * 
      * @var int
      */
-    public $data_page_offset;
-
+    public $num_values = null;
     /**
-     * Byte offset from the beginning of file to first (only) dictionary page *.
-     *
+     * total byte size of all uncompressed pages in this column chunk (including the headers) *
+     * 
      * @var int
      */
-    public $dictionary_page_offset;
-
+    public $total_uncompressed_size = null;
     /**
-     * Set of all encodings used for pages in this column chunk.
-     * This information can be used to determine if all data pages are
-     * dictionary encoded for example *.
-     *
-     * @var array<PageEncodingStats>
+     * total byte size of all compressed, and potentially encrypted, pages
+     * in this column chunk (including the headers) *
+     * 
+     * @var int
      */
-    public $encoding_stats;
-
+    public $total_compressed_size = null;
     /**
-     * Set of all encodings used for this column. The purpose is to validate
-     * whether we can decode those pages. *.
-     *
-     * @var array<int>
+     * Optional key/value metadata *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\KeyValue[]
      */
-    public $encodings;
-
+    public $key_value_metadata = null;
     /**
-     * Byte offset from beginning of file to root index page *.
-     *
+     * Byte offset from beginning of file to first data page *
+     * 
      * @var int
      */
-    public $index_page_offset;
-
+    public $data_page_offset = null;
     /**
-     * Optional key/value metadata *.
-     *
-     * @var array<KeyValue>
+     * Byte offset from beginning of file to root index page *
+     * 
+     * @var null|int
      */
-    public $key_value_metadata;
-
+    public $index_page_offset = null;
     /**
-     * Number of values in this column *.
-     *
-     * @var int
+     * Byte offset from the beginning of file to first (only) dictionary page *
+     * 
+     * @var null|int
      */
-    public $num_values;
-
+    public $dictionary_page_offset = null;
     /**
-     * Path in schema *.
-     *
-     * @var array<string>
+     * optional statistics for this column chunk
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\Statistics
      */
-    public $path_in_schema;
-
+    public $statistics = null;
     /**
-     * Optional statistics to help estimate total memory when converted to in-memory
-     * representations. The histograms contained in these statistics can
-     * also be useful in some cases for more fine-grained nullability/list length
-     * filter pushdown.
-     *
-     * @var SizeStatistics
+     * Set of all encodings used for pages in this column chunk.
+     * This information can be used to determine if all data pages are
+     * dictionary encoded for example *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\PageEncodingStats[]
      */
-    public $size_statistics;
-
+    public $encoding_stats = null;
     /**
-     * optional statistics for this column chunk.
-     *
-     * @var Statistics
+     * Byte offset from beginning of file to Bloom filter data. *
+     * 
+     * @var null|int
      */
-    public $statistics;
-
+    public $bloom_filter_offset = null;
     /**
-     * total byte size of all compressed, and potentially encrypted, pages
-     * in this column chunk (including the headers) *.
-     *
-     * @var int
+     * Size of Bloom filter data including the serialized header, in bytes.
+     * Added in 2.10 so readers may not read this field from old files and
+     * it can be obtained after the BloomFilterHeader has been deserialized.
+     * Writers should write this field so readers can read the bloom filter
+     * in a single I/O.
+     * 
+     * @var null|int
      */
-    public $total_compressed_size;
-
+    public $bloom_filter_length = null;
     /**
-     * total byte size of all uncompressed pages in this column chunk (including the headers) *.
-     *
-     * @var int
+     * Optional statistics to help estimate total memory when converted to in-memory
+     * representations. The histograms contained in these statistics can
+     * also be useful in some cases for more fine-grained nullability/list length
+     * filter pushdown.
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\SizeStatistics
      */
-    public $total_uncompressed_size;
-
+    public $size_statistics = null;
     /**
-     * Type of this column *.
-     *
-     * @var int
+     * Optional statistics specific for Geometry and Geography logical types
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\GeospatialStatistics
      */
-    public $type;
+    public $geospatial_statistics = null;
 
     public function __construct($vals = null)
     {
@@ -256,66 +255,54 @@ public function __construct($vals = null)
             if (isset($vals['type'])) {
                 $this->type = $vals['type'];
             }
-
             if (isset($vals['encodings'])) {
                 $this->encodings = $vals['encodings'];
             }
-
             if (isset($vals['path_in_schema'])) {
                 $this->path_in_schema = $vals['path_in_schema'];
             }
-
             if (isset($vals['codec'])) {
                 $this->codec = $vals['codec'];
             }
-
             if (isset($vals['num_values'])) {
                 $this->num_values = $vals['num_values'];
             }
-
             if (isset($vals['total_uncompressed_size'])) {
                 $this->total_uncompressed_size = $vals['total_uncompressed_size'];
             }
-
             if (isset($vals['total_compressed_size'])) {
                 $this->total_compressed_size = $vals['total_compressed_size'];
             }
-
             if (isset($vals['key_value_metadata'])) {
                 $this->key_value_metadata = $vals['key_value_metadata'];
             }
-
             if (isset($vals['data_page_offset'])) {
                 $this->data_page_offset = $vals['data_page_offset'];
             }
-
             if (isset($vals['index_page_offset'])) {
                 $this->index_page_offset = $vals['index_page_offset'];
             }
-
             if (isset($vals['dictionary_page_offset'])) {
                 $this->dictionary_page_offset = $vals['dictionary_page_offset'];
             }
-
             if (isset($vals['statistics'])) {
                 $this->statistics = $vals['statistics'];
             }
-
             if (isset($vals['encoding_stats'])) {
                 $this->encoding_stats = $vals['encoding_stats'];
             }
-
             if (isset($vals['bloom_filter_offset'])) {
                 $this->bloom_filter_offset = $vals['bloom_filter_offset'];
             }
-
             if (isset($vals['bloom_filter_length'])) {
                 $this->bloom_filter_length = $vals['bloom_filter_length'];
             }
-
             if (isset($vals['size_statistics'])) {
                 $this->size_statistics = $vals['size_statistics'];
             }
+            if (isset($vals['geospatial_statistics'])) {
+                $this->geospatial_statistics = $vals['geospatial_statistics'];
+            }
         }
     }
 
@@ -324,6 +311,7 @@ public function getName()
         return 'ColumnMetaData';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -331,14 +319,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -346,43 +331,38 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::LST) {
-                        $this->encodings = [];
-                        $_size14 = 0;
-                        $_etype17 = 0;
-                        $xfer += $input->readListBegin($_etype17, $_size14);
-
-                        for ($_i18 = 0; $_i18 < $_size14; $_i18++) {
-                            $elem19 = null;
-                            $xfer += $input->readI32($elem19);
-                            $this->encodings[] = $elem19;
+                        $this->encodings = array();
+                        $_size21 = 0;
+                        $_etype24 = 0;
+                        $xfer += $input->readListBegin($_etype24, $_size21);
+                        for ($_i25 = 0; $_i25 < $_size21; ++$_i25) {
+                            $elem26 = null;
+                            $xfer += $input->readI32($elem26);
+                            $this->encodings []= $elem26;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::LST) {
-                        $this->path_in_schema = [];
-                        $_size20 = 0;
-                        $_etype23 = 0;
-                        $xfer += $input->readListBegin($_etype23, $_size20);
-
-                        for ($_i24 = 0; $_i24 < $_size20; $_i24++) {
-                            $elem25 = null;
-                            $xfer += $input->readString($elem25);
-                            $this->path_in_schema[] = $elem25;
+                        $this->path_in_schema = array();
+                        $_size27 = 0;
+                        $_etype30 = 0;
+                        $xfer += $input->readListBegin($_etype30, $_size27);
+                        for ($_i31 = 0; $_i31 < $_size27; ++$_i31) {
+                            $elem32 = null;
+                            $xfer += $input->readString($elem32);
+                            $this->path_in_schema []= $elem32;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I32) {
@@ -390,7 +370,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::I64) {
@@ -398,7 +377,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::I64) {
@@ -406,7 +384,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::I64) {
@@ -414,26 +391,23 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::LST) {
-                        $this->key_value_metadata = [];
-                        $_size26 = 0;
-                        $_etype29 = 0;
-                        $xfer += $input->readListBegin($_etype29, $_size26);
-
-                        for ($_i30 = 0; $_i30 < $_size26; $_i30++) {
-                            $elem31 = null;
-                            $elem31 = new KeyValue();
-                            $xfer += $elem31->read($input);
-                            $this->key_value_metadata[] = $elem31;
+                        $this->key_value_metadata = array();
+                        $_size33 = 0;
+                        $_etype36 = 0;
+                        $xfer += $input->readListBegin($_etype36, $_size33);
+                        for ($_i37 = 0; $_i37 < $_size33; ++$_i37) {
+                            $elem38 = null;
+                            $elem38 = new \Flow\Parquet\ThriftModel\KeyValue();
+                            $xfer += $elem38->read($input);
+                            $this->key_value_metadata []= $elem38;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 9:
                     if ($ftype == TType::I64) {
@@ -441,7 +415,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 10:
                     if ($ftype == TType::I64) {
@@ -449,7 +422,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 11:
                     if ($ftype == TType::I64) {
@@ -457,35 +429,31 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 12:
                     if ($ftype == TType::STRUCT) {
-                        $this->statistics = new Statistics();
+                        $this->statistics = new \Flow\Parquet\ThriftModel\Statistics();
                         $xfer += $this->statistics->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 13:
                     if ($ftype == TType::LST) {
-                        $this->encoding_stats = [];
-                        $_size32 = 0;
-                        $_etype35 = 0;
-                        $xfer += $input->readListBegin($_etype35, $_size32);
-
-                        for ($_i36 = 0; $_i36 < $_size32; $_i36++) {
-                            $elem37 = null;
-                            $elem37 = new PageEncodingStats();
-                            $xfer += $elem37->read($input);
-                            $this->encoding_stats[] = $elem37;
+                        $this->encoding_stats = array();
+                        $_size39 = 0;
+                        $_etype42 = 0;
+                        $xfer += $input->readListBegin($_etype42, $_size39);
+                        for ($_i43 = 0; $_i43 < $_size39; ++$_i43) {
+                            $elem44 = null;
+                            $elem44 = new \Flow\Parquet\ThriftModel\PageEncodingStats();
+                            $xfer += $elem44->read($input);
+                            $this->encoding_stats []= $elem44;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 14:
                     if ($ftype == TType::I64) {
@@ -493,7 +461,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 15:
                     if ($ftype == TType::I32) {
@@ -501,27 +468,30 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 16:
                     if ($ftype == TType::STRUCT) {
-                        $this->size_statistics = new SizeStatistics();
+                        $this->size_statistics = new \Flow\Parquet\ThriftModel\SizeStatistics();
                         $xfer += $this->size_statistics->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
+                case 17:
+                    if ($ftype == TType::STRUCT) {
+                        $this->geospatial_statistics = new \Flow\Parquet\ThriftModel\GeospatialStatistics();
+                        $xfer += $this->geospatial_statistics->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -529,97 +499,82 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('ColumnMetaData');
-
         if ($this->type !== null) {
             $xfer += $output->writeFieldBegin('type', TType::I32, 1);
             $xfer += $output->writeI32($this->type);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encodings !== null) {
             if (!is_array($this->encodings)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('encodings', TType::LST, 2);
             $output->writeListBegin(TType::I32, count($this->encodings));
-
-            foreach ($this->encodings as $iter38) {
-                $xfer += $output->writeI32($iter38);
+            foreach ($this->encodings as $iter45) {
+                $xfer += $output->writeI32($iter45);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->path_in_schema !== null) {
             if (!is_array($this->path_in_schema)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('path_in_schema', TType::LST, 3);
             $output->writeListBegin(TType::STRING, count($this->path_in_schema));
-
-            foreach ($this->path_in_schema as $iter39) {
-                $xfer += $output->writeString($iter39);
+            foreach ($this->path_in_schema as $iter46) {
+                $xfer += $output->writeString($iter46);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->codec !== null) {
             $xfer += $output->writeFieldBegin('codec', TType::I32, 4);
             $xfer += $output->writeI32($this->codec);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->num_values !== null) {
             $xfer += $output->writeFieldBegin('num_values', TType::I64, 5);
             $xfer += $output->writeI64($this->num_values);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->total_uncompressed_size !== null) {
             $xfer += $output->writeFieldBegin('total_uncompressed_size', TType::I64, 6);
             $xfer += $output->writeI64($this->total_uncompressed_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->total_compressed_size !== null) {
             $xfer += $output->writeFieldBegin('total_compressed_size', TType::I64, 7);
             $xfer += $output->writeI64($this->total_compressed_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->key_value_metadata !== null) {
             if (!is_array($this->key_value_metadata)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('key_value_metadata', TType::LST, 8);
             $output->writeListBegin(TType::STRUCT, count($this->key_value_metadata));
-
-            foreach ($this->key_value_metadata as $iter40) {
-                $xfer += $iter40->write($output);
+            foreach ($this->key_value_metadata as $iter47) {
+                $xfer += $iter47->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->data_page_offset !== null) {
             $xfer += $output->writeFieldBegin('data_page_offset', TType::I64, 9);
             $xfer += $output->writeI64($this->data_page_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->index_page_offset !== null) {
             $xfer += $output->writeFieldBegin('index_page_offset', TType::I64, 10);
             $xfer += $output->writeI64($this->index_page_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->dictionary_page_offset !== null) {
             $xfer += $output->writeFieldBegin('dictionary_page_offset', TType::I64, 11);
             $xfer += $output->writeI64($this->dictionary_page_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->statistics !== null) {
             if (!is_object($this->statistics)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -628,33 +583,28 @@ public function write($output)
             $xfer += $this->statistics->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encoding_stats !== null) {
             if (!is_array($this->encoding_stats)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('encoding_stats', TType::LST, 13);
             $output->writeListBegin(TType::STRUCT, count($this->encoding_stats));
-
-            foreach ($this->encoding_stats as $iter41) {
-                $xfer += $iter41->write($output);
+            foreach ($this->encoding_stats as $iter48) {
+                $xfer += $iter48->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->bloom_filter_offset !== null) {
             $xfer += $output->writeFieldBegin('bloom_filter_offset', TType::I64, 14);
             $xfer += $output->writeI64($this->bloom_filter_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->bloom_filter_length !== null) {
             $xfer += $output->writeFieldBegin('bloom_filter_length', TType::I32, 15);
             $xfer += $output->writeI32($this->bloom_filter_length);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->size_statistics !== null) {
             if (!is_object($this->size_statistics)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -663,9 +613,16 @@ public function write($output)
             $xfer += $this->size_statistics->write($output);
             $xfer += $output->writeFieldEnd();
         }
+        if ($this->geospatial_statistics !== null) {
+            if (!is_object($this->geospatial_statistics)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('geospatial_statistics', TType::STRUCT, 17);
+            $xfer += $this->geospatial_statistics->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnOrder.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnOrder.php
index d57d511bb3..6bded71e2e 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnOrder.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ColumnOrder.php
@@ -1,43 +1,60 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Union to specify the order used for the min_value and max_value fields for a
  * column. This union takes the role of an enhanced enum that allows rich
  * elements (which will be needed for a collation-based ordering in the future).
- *
+ * 
  * Possible values are:
  * * TypeDefinedOrder - the column uses the order defined by its logical or
  *                      physical type (if there is no logical type).
- *
+ * * IEEE754TotalOrder - the floating point column uses IEEE 754 total order.
+ * 
+ * * Int96TimestampOrder - the INT96 column uses chronological timestamp order.
+ * 
  * If the reader does not support the value of this union, min and max stats
  * for this column should be ignored.
  */
 class ColumnOrder
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'TYPE_ORDER',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\TypeDefinedOrder',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+        2 => array(
+            'var' => 'IEEE_754_TOTAL_ORDER',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\IEEE754TotalOrder',
+        ),
+        3 => array(
+            'var' => 'INT96_TIMESTAMP_ORDER',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\Int96TimestampOrder',
+        ),
+    );
 
     /**
      * The sort orders for logical types are:
@@ -52,6 +69,7 @@ class ColumnOrder
      *   UINT64 - unsigned comparison
      *   DECIMAL - signed comparison of the represented value
      *   DATE - signed comparison
+     *   FLOAT16 - signed comparison of the represented value (*)
      *   TIME_MILLIS - signed comparison
      *   TIME_MICROS - signed comparison
      *   TIMESTAMP_MILLIS - signed comparison
@@ -62,36 +80,87 @@ class ColumnOrder
      *   ENUM - unsigned byte-wise comparison
      *   LIST - undefined
      *   MAP - undefined
-     *
+     *   VARIANT - undefined
+     *   GEOMETRY - undefined
+     *   GEOGRAPHY - undefined
+     *   FILE - undefined
+     * 
      * In the absence of logical types, the sort order is determined by the physical type:
      *   BOOLEAN - false, true
      *   INT32 - signed comparison
      *   INT64 - signed comparison
-     *   INT96 (only used for legacy timestamps) - undefined
+     *   INT96 (only used for legacy timestamps) - depends on sort order (+)
      *   FLOAT - signed comparison of the represented value (*)
      *   DOUBLE - signed comparison of the represented value (*)
      *   BYTE_ARRAY - unsigned byte-wise comparison
      *   FIXED_LEN_BYTE_ARRAY - unsigned byte-wise comparison
-     *
-     * (*) Because the sorting order is not specified properly for floating
-     *     point values (relations vs. total ordering) the following
+     * 
+     * (+) While the INT96 type has been deprecated, at the time of writing it is
+     *     still used in many legacy systems. It is optional for writers to emit
+     *     statistics for INT96 columns. Writers that emit stats for such columns
+     *     should use the INT96_TIMESTAMP_ORDER for this type and order the values
+     *     according to the legacy rules:
+     *     - compare the last 4 bytes (days) as a little-endian 32-bit signed integer
+     *     - if equal last 4 bytes, compare the first 8 bytes as a little-endian
+     *       64-bit signed integer (nanos)
+     *     If TYPE_ORDER is used for an INT96 column, readers should ignore all statistics
+     *     (`min`/`max` fields in `Statistics` and `min_values`/`max_values` fields in
+     *     `ColumnIndex`) for that column.
+     * 
+     * (*) Because TYPE_ORDER is ambiguous for floating point types due to
+     *     underspecified handling of NaN and -0/+0, it is recommended that writers
+     *     use IEEE_754_TOTAL_ORDER for these types.
+     * 
+     *     If TYPE_ORDER is used for floating point types, then the following
      *     compatibility rules should be applied when reading statistics:
      *     - If the min is a NaN, it should be ignored.
      *     - If the max is a NaN, it should be ignored.
+     *     - If the nan_count field is set, a reader can compute
+     *       nan_count + null_count == num_values to deduce whether all non-null
+     *       values are NaN.
      *     - If the min is +0, the row group may contain -0 values as well.
      *     - If the max is -0, the row group may contain +0 values as well.
      *     - When looking for NaN values, min and max should be ignored.
-     *
-     *     When writing statistics the following rules should be followed:
-     *     - NaNs should not be written to min or max statistics fields.
+     *       If the nan_count field is set, it can be used to check whether
+     *       NaNs are present.
+     * 
+     *     When writing page or column chunk statistics for columns with
+     *     TYPE_ORDER order, the following rules must be followed:
+     *     - The nan_count field must be set for floating point types, even if
+     *       it is zero.
+     *     - If the nan_count field is set, min and max statistics fields, when
+     *       present, must not contain NaN values and must be computed from
+     *       non-NaN values only. This signals to readers that the min and max
+     *       statistics are reliable for non-NaN values.
+     *     - If all non-null values are NaN, min and max statistics must not be
+     *       written.
      *     - If the computed max value is zero (whether negative or positive),
      *       `+0.0` should be written into the max statistics field.
      *     - If the computed min value is zero (whether negative or positive),
      *       `-0.0` should be written into the min statistics field.
-     *
-     * @var TypeDefinedOrder
+     * 
+     *     When writing column indexes for columns with TYPE_ORDER order, the
+     *     following rules must be followed:
+     *     - NaNs must not be written to min_values or max_values.
+     *     - If all non-null values of a page are NaN, a column index must not
+     *       be written for this column chunk because min_values and max_values
+     *       are required.
+     *     - If the computed max value is zero (whether negative or positive),
+     *       `+0.0` should be written into the corresponding max_values entry.
+     *     - If the computed min value is zero (whether negative or positive),
+     *       `-0.0` should be written into the corresponding min_values entry.
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\TypeDefinedOrder
+     */
+    public $TYPE_ORDER = null;
+    /**
+     * @var null|\Flow\Parquet\ThriftModel\IEEE754TotalOrder
+     */
+    public $IEEE_754_TOTAL_ORDER = null;
+    /**
+     * @var null|\Flow\Parquet\ThriftModel\Int96TimestampOrder
      */
-    public $TYPE_ORDER;
+    public $INT96_TIMESTAMP_ORDER = null;
 
     public function __construct($vals = null)
     {
@@ -99,6 +168,12 @@ public function __construct($vals = null)
             if (isset($vals['TYPE_ORDER'])) {
                 $this->TYPE_ORDER = $vals['TYPE_ORDER'];
             }
+            if (isset($vals['IEEE_754_TOTAL_ORDER'])) {
+                $this->IEEE_754_TOTAL_ORDER = $vals['IEEE_754_TOTAL_ORDER'];
+            }
+            if (isset($vals['INT96_TIMESTAMP_ORDER'])) {
+                $this->INT96_TIMESTAMP_ORDER = $vals['INT96_TIMESTAMP_ORDER'];
+            }
         }
     }
 
@@ -107,6 +182,7 @@ public function getName()
         return 'ColumnOrder';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -114,34 +190,43 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->TYPE_ORDER = new TypeDefinedOrder();
+                        $this->TYPE_ORDER = new \Flow\Parquet\ThriftModel\TypeDefinedOrder();
                         $xfer += $this->TYPE_ORDER->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
+                case 2:
+                    if ($ftype == TType::STRUCT) {
+                        $this->IEEE_754_TOTAL_ORDER = new \Flow\Parquet\ThriftModel\IEEE754TotalOrder();
+                        $xfer += $this->IEEE_754_TOTAL_ORDER->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 3:
+                    if ($ftype == TType::STRUCT) {
+                        $this->INT96_TIMESTAMP_ORDER = new \Flow\Parquet\ThriftModel\Int96TimestampOrder();
+                        $xfer += $this->INT96_TIMESTAMP_ORDER->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -149,7 +234,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('ColumnOrder');
-
         if ($this->TYPE_ORDER !== null) {
             if (!is_object($this->TYPE_ORDER)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -158,9 +242,24 @@ public function write($output)
             $xfer += $this->TYPE_ORDER->write($output);
             $xfer += $output->writeFieldEnd();
         }
+        if ($this->IEEE_754_TOTAL_ORDER !== null) {
+            if (!is_object($this->IEEE_754_TOTAL_ORDER)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('IEEE_754_TOTAL_ORDER', TType::STRUCT, 2);
+            $xfer += $this->IEEE_754_TOTAL_ORDER->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->INT96_TIMESTAMP_ORDER !== null) {
+            if (!is_object($this->INT96_TIMESTAMP_ORDER)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('INT96_TIMESTAMP_ORDER', TType::STRUCT, 3);
+            $xfer += $this->INT96_TIMESTAMP_ORDER->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/CompressionCodec.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/CompressionCodec.php
index ae9988e5aa..4bfb4474e5 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/CompressionCodec.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/CompressionCodec.php
@@ -1,44 +1,49 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 /**
  * Supported compression algorithms.
- *
+ * 
  * Codecs added in format version X.Y can be read by readers based on X.Y and later.
  * Codec support may vary between readers based on the format version and
  * libraries available at runtime.
- *
+ * 
  * See Compression.md for a detailed specification of these algorithms.
  */
 final class CompressionCodec
 {
-    public const BROTLI = 4;
+    const UNCOMPRESSED = 0;
 
-    public const GZIP = 2;
+    const SNAPPY = 1;
 
-    public const LZ4 = 5;
+    const GZIP = 2;
 
-    public const LZ4_RAW = 7;
+    const LZO = 3;
 
-    public const LZO = 3;
+    const BROTLI = 4;
 
-    public const SNAPPY = 1;
+    const LZ4 = 5;
 
-    public const UNCOMPRESSED = 0;
+    const ZSTD = 6;
 
-    public const ZSTD = 6;
+    const LZ4_RAW = 7;
 
-    public static $__names = [
+    static public $__names = array(
         0 => 'UNCOMPRESSED',
         1 => 'SNAPPY',
         2 => 'GZIP',
@@ -47,5 +52,6 @@ final class CompressionCodec
         5 => 'LZ4',
         6 => 'ZSTD',
         7 => 'LZ4_RAW',
-    ];
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ConvertedType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ConvertedType.php
index 29abd96ff5..5674770949 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ConvertedType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ConvertedType.php
@@ -1,166 +1,174 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 /**
- * DEPRECATED: Common types used by frameworks(e.g. hive, pig) using parquet.
+ * DEPRECATED: Common types used by frameworks (e.g. Hive, Pig) using parquet.
  * ConvertedType is superseded by LogicalType.  This enum should not be extended.
- *
+ * 
  * See LogicalTypes.md for conversion between ConvertedType and LogicalType.
  */
 final class ConvertedType
 {
     /**
-     * An embedded BSON document.
-     *
-     * A BSON document embedded within a single BYTE_ARRAY column.
+     * a BYTE_ARRAY actually contains UTF8 encoded chars
      */
-    public const BSON = 20;
+    const UTF8 = 0;
 
     /**
-     * A Date.
-     *
-     * Stored as days since Unix epoch, encoded as the INT32 physical type.
+     * a map is converted as an optional field containing a repeated key/value pair
+     */
+    const MAP = 1;
+
+    /**
+     * a key/value pair is converted into a group of two fields
+     */
+    const MAP_KEY_VALUE = 2;
+
+    /**
+     * a list is converted into an optional field containing a repeated field for its
+     * values
+     */
+    const LIST = 3;
+
+    /**
+     * an enum is converted into a BYTE_ARRAY field
      */
-    public const DATE = 6;
+    const ENUM = 4;
 
     /**
      * A decimal value.
-     *
+     * 
      * This may be used to annotate BYTE_ARRAY or FIXED_LEN_BYTE_ARRAY primitive
      * types. The underlying byte array stores the unscaled value encoded as two's
      * complement using big-endian byte order (the most significant byte is the
      * zeroth element). The value of the decimal is the value * 10^{-scale}.
-     *
+     * 
      * This must be accompanied by a (maximum) precision and a scale in the
      * SchemaElement. The precision specifies the number of digits in the decimal
      * and the scale stores the location of the decimal point. For example 1.23
      * would have precision 3 (3 total digits) and scale 2 (the decimal point is
      * 2 digits over).
      */
-    public const DECIMAL = 5;
-
-    /**
-     * an enum is converted into a BYTE_ARRAY field.
-     */
-    public const ENUM = 4;
-
-    public const INT_16 = 16;
-
-    public const INT_32 = 17;
-
-    public const INT_64 = 18;
-
-    /**
-     * A signed integer value.
-     *
-     * The number describes the maximum number of meaningful data bits in
-     * the stored value. 8, 16 and 32 bit values are stored using the
-     * INT32 physical type.  64 bit values are stored using the INT64
-     * physical type.
-     */
-    public const INT_8 = 15;
-
-    /**
-     * An interval of time.
-     *
-     * This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
-     * This data is composed of three separate little endian unsigned
-     * integers.  Each stores a component of a duration of time.  The first
-     * integer identifies the number of months associated with the duration,
-     * the second identifies the number of days associated with the duration
-     * and the third identifies the number of milliseconds associated with
-     * the provided duration.  This duration of time is independent of any
-     * particular timezone or date.
-     */
-    public const INTERVAL = 21;
+    const DECIMAL = 5;
 
     /**
-     * An embedded JSON document.
-     *
-     * A JSON document embedded within a single UTF8 column.
-     */
-    public const JSON = 19;
-
-    /**
-     * a list is converted into an optional field containing a repeated field for its
-     * values.
-     */
-    public const LIST = 3;
-
-    /**
-     * a map is converted as an optional field containing a repeated key/value pair.
+     * A Date
+     * 
+     * Stored as days since Unix epoch, encoded as the INT32 physical type.
+     * 
      */
-    public const MAP = 1;
+    const DATE = 6;
 
     /**
-     * a key/value pair is converted into a group of two fields.
+     * A time
+     * 
+     * The total number of milliseconds since midnight.  The value is stored
+     * as an INT32 physical type.
      */
-    public const MAP_KEY_VALUE = 2;
+    const TIME_MILLIS = 7;
 
     /**
      * A time.
-     *
+     * 
      * The total number of microseconds since midnight.  The value is stored as
      * an INT64 physical type.
      */
-    public const TIME_MICROS = 8;
+    const TIME_MICROS = 8;
 
     /**
-     * A time.
-     *
-     * The total number of milliseconds since midnight.  The value is stored
-     * as an INT32 physical type.
+     * A date/time combination
+     * 
+     * Date and time recorded as milliseconds since the Unix epoch.  Recorded as
+     * a physical type of INT64.
      */
-    public const TIME_MILLIS = 7;
+    const TIMESTAMP_MILLIS = 9;
 
     /**
-     * A date/time combination.
-     *
+     * A date/time combination
+     * 
      * Date and time recorded as microseconds since the Unix epoch.  The value is
      * stored as an INT64 physical type.
      */
-    public const TIMESTAMP_MICROS = 10;
+    const TIMESTAMP_MICROS = 10;
 
     /**
-     * A date/time combination.
-     *
-     * Date and time recorded as milliseconds since the Unix epoch.  Recorded as
-     * a physical type of INT64.
+     * An unsigned integer value.
+     * 
+     * The number describes the maximum number of meaningful data bits in
+     * the stored value. 8, 16 and 32 bit values are stored using the
+     * INT32 physical type.  64 bit values are stored using the INT64
+     * physical type.
+     * 
      */
-    public const TIMESTAMP_MILLIS = 9;
+    const UINT_8 = 11;
 
-    public const UINT_16 = 12;
+    const UINT_16 = 12;
 
-    public const UINT_32 = 13;
+    const UINT_32 = 13;
 
-    public const UINT_64 = 14;
+    const UINT_64 = 14;
 
     /**
-     * An unsigned integer value.
-     *
+     * A signed integer value.
+     * 
      * The number describes the maximum number of meaningful data bits in
      * the stored value. 8, 16 and 32 bit values are stored using the
      * INT32 physical type.  64 bit values are stored using the INT64
      * physical type.
+     * 
      */
-    public const UINT_8 = 11;
+    const INT_8 = 15;
+
+    const INT_16 = 16;
+
+    const INT_32 = 17;
+
+    const INT_64 = 18;
 
     /**
-     * a BYTE_ARRAY actually contains UTF8 encoded chars.
+     * An embedded JSON document
+     * 
+     * A JSON document embedded within a single UTF8 column.
      */
-    public const UTF8 = 0;
+    const JSON = 19;
 
-    public static $__names = [
+    /**
+     * An embedded BSON document
+     * 
+     * A BSON document embedded within a single BYTE_ARRAY column.
+     */
+    const BSON = 20;
+
+    /**
+     * An interval of time
+     * 
+     * This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
+     * This data is composed of three separate little endian unsigned
+     * integers.  Each stores a component of a duration of time.  The first
+     * integer identifies the number of months associated with the duration,
+     * the second identifies the number of days associated with the duration
+     * and the third identifies the number of milliseconds associated with
+     * the provided duration.  This duration of time is independent of any
+     * particular timezone or date.
+     */
+    const INTERVAL = 21;
+
+    static public $__names = array(
         0 => 'UTF8',
         1 => 'MAP',
         2 => 'MAP_KEY_VALUE',
@@ -183,5 +191,6 @@ final class ConvertedType
         19 => 'JSON',
         20 => 'BSON',
         21 => 'INTERVAL',
-    ];
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeader.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeader.php
index b61754efa5..4015ff9105 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeader.php
@@ -1,96 +1,95 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Data page header.
+ * Data page header
  */
 class DataPageHeader
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'num_values',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'encoding',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Encoding',
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'definition_level_encoding',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Encoding',
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'repetition_level_encoding',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Encoding',
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'statistics',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\Statistics',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Encoding used for definition levels *.
-     *
+     * Number of values, including NULLs, in this data page.
+     * 
+     * If an OffsetIndex is present, a page must begin at a row
+     * boundary (repetition_level = 0). Otherwise, pages may begin
+     * within a row (repetition_level > 0).
+     * 
+     * 
      * @var int
      */
-    public $definition_level_encoding;
-
+    public $num_values = null;
     /**
-     * Encoding used for this data page *.
-     *
+     * Encoding used for this data page *
+     * 
      * @var int
      */
-    public $encoding;
-
+    public $encoding = null;
     /**
-     * Number of values, including NULLs, in this data page.
-     *
-     * If a OffsetIndex is present, a page must begin at a row
-     * boundary (repetition_level = 0). Otherwise, pages may begin
-     * within a row (repetition_level > 0).
-     *
+     * Encoding used for definition levels *
+     * 
      * @var int
      */
-    public $num_values;
-
+    public $definition_level_encoding = null;
     /**
-     * Encoding used for repetition levels *.
-     *
+     * Encoding used for repetition levels *
+     * 
      * @var int
      */
-    public $repetition_level_encoding;
-
+    public $repetition_level_encoding = null;
     /**
-     * Optional statistics for the data in this page *.
-     *
-     * @var Statistics
+     * Optional statistics for the data in this page *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\Statistics
      */
-    public $statistics;
+    public $statistics = null;
 
     public function __construct($vals = null)
     {
@@ -98,19 +97,15 @@ public function __construct($vals = null)
             if (isset($vals['num_values'])) {
                 $this->num_values = $vals['num_values'];
             }
-
             if (isset($vals['encoding'])) {
                 $this->encoding = $vals['encoding'];
             }
-
             if (isset($vals['definition_level_encoding'])) {
                 $this->definition_level_encoding = $vals['definition_level_encoding'];
             }
-
             if (isset($vals['repetition_level_encoding'])) {
                 $this->repetition_level_encoding = $vals['repetition_level_encoding'];
             }
-
             if (isset($vals['statistics'])) {
                 $this->statistics = $vals['statistics'];
             }
@@ -122,6 +117,7 @@ public function getName()
         return 'DataPageHeader';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -129,14 +125,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -144,7 +137,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -152,7 +144,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I32) {
@@ -160,7 +151,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I32) {
@@ -168,27 +158,22 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::STRUCT) {
-                        $this->statistics = new Statistics();
+                        $this->statistics = new \Flow\Parquet\ThriftModel\Statistics();
                         $xfer += $this->statistics->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -196,31 +181,26 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('DataPageHeader');
-
         if ($this->num_values !== null) {
             $xfer += $output->writeFieldBegin('num_values', TType::I32, 1);
             $xfer += $output->writeI32($this->num_values);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encoding !== null) {
             $xfer += $output->writeFieldBegin('encoding', TType::I32, 2);
             $xfer += $output->writeI32($this->encoding);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->definition_level_encoding !== null) {
             $xfer += $output->writeFieldBegin('definition_level_encoding', TType::I32, 3);
             $xfer += $output->writeI32($this->definition_level_encoding);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->repetition_level_encoding !== null) {
             $xfer += $output->writeFieldBegin('repetition_level_encoding', TType::I32, 4);
             $xfer += $output->writeI32($this->repetition_level_encoding);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->statistics !== null) {
             if (!is_object($this->statistics)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -231,7 +211,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeaderV2.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeaderV2.php
index 91f25116c0..feebc11fd5 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeaderV2.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DataPageHeaderV2.php
@@ -1,135 +1,137 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * New page format allowing reading levels without decompressing the data
+ * Alternate page format allowing reading levels without decompressing the data
  * Repetition and definition levels are uncompressed
- * The remaining section containing the data is compressed if is_compressed is true.
+ * The remaining section containing the data is compressed if is_compressed is true
+ * 
+ * Implementation note - this header is not necessarily a strict improvement over
+ * `DataPageHeader` (in particular the original header might provide better compression
+ * in some scenarios). Page indexes require pages to start and end at row boundaries,
+ * regardless of which page header is used.
+ * 
  */
 class DataPageHeaderV2
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'num_values',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'num_nulls',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'num_rows',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'encoding',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Encoding',
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'definition_levels_byte_length',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'repetition_levels_byte_length',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'is_compressed',
             'isRequired' => false,
             'type' => TType::BOOL,
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'statistics',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\Statistics',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Length of the definition levels.
-     *
+     * Number of values, including NULLs, in this data page. *
+     * 
      * @var int
      */
-    public $definition_levels_byte_length;
-
-    /**
-     * Encoding used for data in this page *.
-     *
-     * @var int
-     */
-    public $encoding;
-
-    /**
-     * Whether the values are compressed.
-     * Which means the section of the page between
-     * definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included)
-     * is compressed with the compression_codec.
-     * If missing it is considered compressed.
-     *
-     * @var bool
-     */
-    public $is_compressed = true;
-
+    public $num_values = null;
     /**
      * Number of NULL values, in this data page.
-     * Number of non-null = num_values - num_nulls which is also the number of values in the data section *.
-     *
+     * Number of non-null = num_values - num_nulls which is also the number of values in the data section *
+     * 
      * @var int
      */
-    public $num_nulls;
-
+    public $num_nulls = null;
     /**
      * Number of rows in this data page. Every page must begin at a
      * row boundary (repetition_level = 0): rows must **not** be
      * split across page boundaries when using V2 data pages.
-     *
+     * 
+     * 
      * @var int
      */
-    public $num_rows;
-
+    public $num_rows = null;
     /**
-     * Number of values, including NULLs, in this data page. *.
-     *
+     * Encoding used for data in this page *
+     * 
      * @var int
      */
-    public $num_values;
-
+    public $encoding = null;
     /**
-     * Length of the repetition levels.
-     *
+     * Length of the definition levels
+     * 
      * @var int
      */
-    public $repetition_levels_byte_length;
-
+    public $definition_levels_byte_length = null;
+    /**
+     * Length of the repetition levels
+     * 
+     * @var int
+     */
+    public $repetition_levels_byte_length = null;
     /**
-     * Optional statistics for the data in this page *.
-     *
-     * @var Statistics
+     * Whether the values are compressed.
+     * Which means the section of the page between
+     * definition_levels_byte_length + repetition_levels_byte_length and compressed_page_size (included)
+     * is compressed with the compression_codec.
+     * If missing it is considered compressed
+     * 
+     * @var bool
      */
-    public $statistics;
+    public $is_compressed = true;
+    /**
+     * Optional statistics for the data in this page *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\Statistics
+     */
+    public $statistics = null;
 
     public function __construct($vals = null)
     {
@@ -137,31 +139,24 @@ public function __construct($vals = null)
             if (isset($vals['num_values'])) {
                 $this->num_values = $vals['num_values'];
             }
-
             if (isset($vals['num_nulls'])) {
                 $this->num_nulls = $vals['num_nulls'];
             }
-
             if (isset($vals['num_rows'])) {
                 $this->num_rows = $vals['num_rows'];
             }
-
             if (isset($vals['encoding'])) {
                 $this->encoding = $vals['encoding'];
             }
-
             if (isset($vals['definition_levels_byte_length'])) {
                 $this->definition_levels_byte_length = $vals['definition_levels_byte_length'];
             }
-
             if (isset($vals['repetition_levels_byte_length'])) {
                 $this->repetition_levels_byte_length = $vals['repetition_levels_byte_length'];
             }
-
             if (isset($vals['is_compressed'])) {
                 $this->is_compressed = $vals['is_compressed'];
             }
-
             if (isset($vals['statistics'])) {
                 $this->statistics = $vals['statistics'];
             }
@@ -173,6 +168,7 @@ public function getName()
         return 'DataPageHeaderV2';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -180,14 +176,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -195,7 +188,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -203,7 +195,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I32) {
@@ -211,7 +202,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I32) {
@@ -219,7 +209,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::I32) {
@@ -227,7 +216,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::I32) {
@@ -235,7 +223,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::BOOL) {
@@ -243,27 +230,22 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::STRUCT) {
-                        $this->statistics = new Statistics();
+                        $this->statistics = new \Flow\Parquet\ThriftModel\Statistics();
                         $xfer += $this->statistics->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -271,49 +253,41 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('DataPageHeaderV2');
-
         if ($this->num_values !== null) {
             $xfer += $output->writeFieldBegin('num_values', TType::I32, 1);
             $xfer += $output->writeI32($this->num_values);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->num_nulls !== null) {
             $xfer += $output->writeFieldBegin('num_nulls', TType::I32, 2);
             $xfer += $output->writeI32($this->num_nulls);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->num_rows !== null) {
             $xfer += $output->writeFieldBegin('num_rows', TType::I32, 3);
             $xfer += $output->writeI32($this->num_rows);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encoding !== null) {
             $xfer += $output->writeFieldBegin('encoding', TType::I32, 4);
             $xfer += $output->writeI32($this->encoding);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->definition_levels_byte_length !== null) {
             $xfer += $output->writeFieldBegin('definition_levels_byte_length', TType::I32, 5);
             $xfer += $output->writeI32($this->definition_levels_byte_length);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->repetition_levels_byte_length !== null) {
             $xfer += $output->writeFieldBegin('repetition_levels_byte_length', TType::I32, 6);
             $xfer += $output->writeI32($this->repetition_levels_byte_length);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->is_compressed !== null) {
             $xfer += $output->writeFieldBegin('is_compressed', TType::BOOL, 7);
             $xfer += $output->writeBool($this->is_compressed);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->statistics !== null) {
             if (!is_object($this->statistics)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -324,7 +298,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DateType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DateType.php
index 08ca117240..5829c20b02 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DateType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DateType.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class DateType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'DateType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('DateType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DecimalType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DecimalType.php
index b86b4d62ca..e6f8147a64 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DecimalType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DecimalType.php
@@ -1,55 +1,57 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Decimal logical type annotation.
- *
+ * Decimal logical type annotation
+ * 
  * Scale must be zero or a positive integer less than or equal to the precision.
  * Precision must be a non-zero positive integer.
- *
+ * 
  * To maintain forward-compatibility in v1, implementations using this logical
  * type must also set scale and precision on the annotated SchemaElement.
- *
+ * 
  * Allowed for physical types: INT32, INT64, FIXED_LEN_BYTE_ARRAY, and BYTE_ARRAY.
  */
 class DecimalType
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'scale',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'precision',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * @var int
      */
-    public $precision;
-
+    public $scale = null;
     /**
      * @var int
      */
-    public $scale;
+    public $precision = null;
 
     public function __construct($vals = null)
     {
@@ -57,7 +59,6 @@ public function __construct($vals = null)
             if (isset($vals['scale'])) {
                 $this->scale = $vals['scale'];
             }
-
             if (isset($vals['precision'])) {
                 $this->precision = $vals['precision'];
             }
@@ -69,6 +70,7 @@ public function getName()
         return 'DecimalType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -76,14 +78,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -91,7 +90,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -99,18 +97,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -118,13 +112,11 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('DecimalType');
-
         if ($this->scale !== null) {
             $xfer += $output->writeFieldBegin('scale', TType::I32, 1);
             $xfer += $output->writeI32($this->scale);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->precision !== null) {
             $xfer += $output->writeFieldBegin('precision', TType::I32, 2);
             $xfer += $output->writeI32($this->precision);
@@ -132,7 +124,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DictionaryPageHeader.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DictionaryPageHeader.php
index f853a893f7..ce4d00b8e5 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/DictionaryPageHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/DictionaryPageHeader.php
@@ -1,66 +1,68 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * The dictionary page must be placed at the first position of the column chunk
  * if it is partly or completely dictionary encoded. At most one dictionary page
  * can be placed in a column chunk.
+ * 
  */
 class DictionaryPageHeader
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'num_values',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'encoding',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Encoding',
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'is_sorted',
             'isRequired' => false,
             'type' => TType::BOOL,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Encoding using this dictionary page *.
-     *
+     * Number of values in the dictionary *
+     * 
      * @var int
      */
-    public $encoding;
-
+    public $num_values = null;
     /**
-     * If true, the entries in the dictionary are sorted in ascending order *.
-     *
-     * @var bool
+     * Encoding using this dictionary page *
+     * 
+     * @var int
      */
-    public $is_sorted;
-
+    public $encoding = null;
     /**
-     * Number of values in the dictionary *.
-     *
-     * @var int
+     * If true, the entries in the dictionary are sorted in ascending order *
+     * 
+     * @var null|bool
      */
-    public $num_values;
+    public $is_sorted = null;
 
     public function __construct($vals = null)
     {
@@ -68,11 +70,9 @@ public function __construct($vals = null)
             if (isset($vals['num_values'])) {
                 $this->num_values = $vals['num_values'];
             }
-
             if (isset($vals['encoding'])) {
                 $this->encoding = $vals['encoding'];
             }
-
             if (isset($vals['is_sorted'])) {
                 $this->is_sorted = $vals['is_sorted'];
             }
@@ -84,6 +84,7 @@ public function getName()
         return 'DictionaryPageHeader';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -91,14 +92,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -106,7 +104,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -114,7 +111,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::BOOL) {
@@ -122,18 +118,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -141,19 +133,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('DictionaryPageHeader');
-
         if ($this->num_values !== null) {
             $xfer += $output->writeFieldBegin('num_values', TType::I32, 1);
             $xfer += $output->writeI32($this->num_values);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encoding !== null) {
             $xfer += $output->writeFieldBegin('encoding', TType::I32, 2);
             $xfer += $output->writeI32($this->encoding);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->is_sorted !== null) {
             $xfer += $output->writeFieldBegin('is_sorted', TType::BOOL, 3);
             $xfer += $output->writeBool($this->is_sorted);
@@ -161,7 +150,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EdgeInterpolationAlgorithm.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EdgeInterpolationAlgorithm.php
new file mode 100644
index 0000000000..915fe20e4c
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EdgeInterpolationAlgorithm.php
@@ -0,0 +1,42 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Edge interpolation algorithm for Geography logical type
+ */
+final class EdgeInterpolationAlgorithm
+{
+    const SPHERICAL = 0;
+
+    const VINCENTY = 1;
+
+    const THOMAS = 2;
+
+    const ANDOYER = 3;
+
+    const KARNEY = 4;
+
+    static public $__names = array(
+        0 => 'SPHERICAL',
+        1 => 'VINCENTY',
+        2 => 'THOMAS',
+        3 => 'ANDOYER',
+        4 => 'KARNEY',
+    );
+}
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Encoding.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Encoding.php
index a122961fcb..03503f3682 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Encoding.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Encoding.php
@@ -1,16 +1,21 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 /**
  * Encodings supported by Parquet.  Not all encodings are valid for all types.  These
  * enums are also used to specify the encoding of definition and repetition levels.
@@ -19,74 +24,84 @@
 final class Encoding
 {
     /**
-     * Bit packed encoding.  This can only be used if the data has a known max
-     * width.  Usable for definition/repetition levels encoding.
+     * Default encoding.
+     * BOOLEAN - 1 bit per value. 0 is false; 1 is true.
+     * INT32 - 4 bytes per value.  Stored as little-endian.
+     * INT64 - 8 bytes per value.  Stored as little-endian.
+     * FLOAT - 4 bytes per value.  IEEE. Stored as little-endian.
+     * DOUBLE - 8 bytes per value.  IEEE. Stored as little-endian.
+     * BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
+     * FIXED_LEN_BYTE_ARRAY - Just the bytes.
      */
-    public const BIT_PACKED = 4;
+    const PLAIN = 0;
 
     /**
-     * Encoding for fixed-width data (FLOAT, DOUBLE, INT32, INT64, FIXED_LEN_BYTE_ARRAY).
-     * K byte-streams are created where K is the size in bytes of the data type.
-     * The individual bytes of a value are scattered to the corresponding stream and
-     * the streams are concatenated.
-     * This itself does not reduce the size of the data but can lead to better compression
-     * afterwards.
-     *
-     * Added in 2.8 for FLOAT and DOUBLE.
-     * Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
+     * DEPRECATED: Dictionary encoding. The values in the dictionary are encoded in the
+     * plain type.
+     * For a data page use RLE_DICTIONARY instead.
+     * For a Dictionary page use PLAIN instead.
      */
-    public const BYTE_STREAM_SPLIT = 9;
+    const PLAIN_DICTIONARY = 2;
 
     /**
-     * Delta encoding for integers. This can be used for int columns and works best
-     * on sorted data.
+     * Group packed run length encoding. Usable for definition/repetition levels
+     * encoding and Booleans (on one bit: 0 is false; 1 is true.)
      */
-    public const DELTA_BINARY_PACKED = 5;
+    const RLE = 3;
 
     /**
-     * Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
-     * Suffixes are stored as delta length byte arrays.
+     * DEPRECATED: Bit packed encoding.  This can only be used if the data has a known max
+     * width.  Usable for definition/repetition levels encoding.
+     * Superseded by RLE (which is a hybrid of RLE and bit packing); see Encodings.md.
      */
-    public const DELTA_BYTE_ARRAY = 7;
+    const BIT_PACKED = 4;
+
+    /**
+     * Delta encoding for integers. This can be used for int columns and works best
+     * on sorted data
+     */
+    const DELTA_BINARY_PACKED = 5;
 
     /**
      * Encoding for byte arrays to separate the length values and the data. The lengths
-     * are encoded using DELTA_BINARY_PACKED.
+     * are encoded using DELTA_BINARY_PACKED
      */
-    public const DELTA_LENGTH_BYTE_ARRAY = 6;
+    const DELTA_LENGTH_BYTE_ARRAY = 6;
 
     /**
-     * Default encoding.
-     * BOOLEAN - 1 bit per value. 0 is false; 1 is true.
-     * INT32 - 4 bytes per value.  Stored as little-endian.
-     * INT64 - 8 bytes per value.  Stored as little-endian.
-     * FLOAT - 4 bytes per value.  IEEE. Stored as little-endian.
-     * DOUBLE - 8 bytes per value.  IEEE. Stored as little-endian.
-     * BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
-     * FIXED_LEN_BYTE_ARRAY - Just the bytes.
+     * Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
+     * Suffixes are stored as delta length byte arrays.
      */
-    public const PLAIN = 0;
+    const DELTA_BYTE_ARRAY = 7;
 
     /**
-     * Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
-     * plain type.
-     * in a data page use RLE_DICTIONARY instead.
-     * in a Dictionary page use PLAIN instead.
+     * Dictionary encoding: the ids are encoded using the RLE encoding
      */
-    public const PLAIN_DICTIONARY = 2;
+    const RLE_DICTIONARY = 8;
 
     /**
-     * Group packed run length encoding. Usable for definition/repetition levels
-     * encoding and Booleans (on one bit: 0 is false; 1 is true.).
+     * Encoding for fixed-width data (FLOAT, DOUBLE, INT32, INT64, FIXED_LEN_BYTE_ARRAY).
+     * K byte-streams are created where K is the size in bytes of the data type.
+     * The individual bytes of a value are scattered to the corresponding stream and
+     * the streams are concatenated.
+     * This itself does not reduce the size of the data but can lead to better compression
+     * afterwards.
+     * 
+     * Added in 2.8 for FLOAT and DOUBLE.
+     * Support for INT32, INT64 and FIXED_LEN_BYTE_ARRAY added in 2.11.
      */
-    public const RLE = 3;
+    const BYTE_STREAM_SPLIT = 9;
 
     /**
-     * Dictionary encoding: the ids are encoded using the RLE encoding.
+     * Adaptive Lossless floating-Point (ALP) encoding for FLOAT and DOUBLE.
+     * Losslessly converts decimal-like floating-point values to integers via
+     * decimal scaling, then applies Frame of Reference (FOR) encoding and
+     * bit-packing; values that cannot be converted losslessly are stored as
+     * exceptions. See Encodings.md for the detailed specification.
      */
-    public const RLE_DICTIONARY = 8;
+    const ALP = 10;
 
-    public static $__names = [
+    static public $__names = array(
         0 => 'PLAIN',
         2 => 'PLAIN_DICTIONARY',
         3 => 'RLE',
@@ -96,5 +111,7 @@ final class Encoding
         7 => 'DELTA_BYTE_ARRAY',
         8 => 'RLE_DICTIONARY',
         9 => 'BYTE_STREAM_SPLIT',
-    ];
+        10 => 'ALP',
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionAlgorithm.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionAlgorithm.php
index c2001cd069..2bdeeb3268 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionAlgorithm.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionAlgorithm.php
@@ -1,47 +1,48 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class EncryptionAlgorithm
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'AES_GCM_V1',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\AesGcmV1',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'AES_GCM_CTR_V1',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\AesGcmCtrV1',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * @var AesGcmCtrV1
+     * @var null|\Flow\Parquet\ThriftModel\AesGcmV1
      */
-    public $AES_GCM_CTR_V1;
-
+    public $AES_GCM_V1 = null;
     /**
-     * @var AesGcmV1
+     * @var null|\Flow\Parquet\ThriftModel\AesGcmCtrV1
      */
-    public $AES_GCM_V1;
+    public $AES_GCM_CTR_V1 = null;
 
     public function __construct($vals = null)
     {
@@ -49,7 +50,6 @@ public function __construct($vals = null)
             if (isset($vals['AES_GCM_V1'])) {
                 $this->AES_GCM_V1 = $vals['AES_GCM_V1'];
             }
-
             if (isset($vals['AES_GCM_CTR_V1'])) {
                 $this->AES_GCM_CTR_V1 = $vals['AES_GCM_CTR_V1'];
             }
@@ -61,6 +61,7 @@ public function getName()
         return 'EncryptionAlgorithm';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -68,43 +69,35 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->AES_GCM_V1 = new AesGcmV1();
+                        $this->AES_GCM_V1 = new \Flow\Parquet\ThriftModel\AesGcmV1();
                         $xfer += $this->AES_GCM_V1->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->AES_GCM_CTR_V1 = new AesGcmCtrV1();
+                        $this->AES_GCM_CTR_V1 = new \Flow\Parquet\ThriftModel\AesGcmCtrV1();
                         $xfer += $this->AES_GCM_CTR_V1->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -112,7 +105,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('EncryptionAlgorithm');
-
         if ($this->AES_GCM_V1 !== null) {
             if (!is_object($this->AES_GCM_V1)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -121,7 +113,6 @@ public function write($output)
             $xfer += $this->AES_GCM_V1->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->AES_GCM_CTR_V1 !== null) {
             if (!is_object($this->AES_GCM_CTR_V1)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -132,7 +123,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithColumnKey.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithColumnKey.php
index 2566004aa1..0fc4d5bc8c 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithColumnKey.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithColumnKey.php
@@ -1,53 +1,54 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class EncryptionWithColumnKey
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'path_in_schema',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRING,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRING,
-            ],
-        ],
-        2 => [
+                ),
+        ),
+        2 => array(
             'var' => 'key_metadata',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Retrieval metadata of column encryption key *.
-     *
-     * @var string
+     * Column path in schema *
+     * 
+     * @var string[]
      */
-    public $key_metadata;
-
+    public $path_in_schema = null;
     /**
-     * Column path in schema *.
-     *
-     * @var array<string>
+     * Retrieval metadata of column encryption key *
+     * 
+     * @var null|string
      */
-    public $path_in_schema;
+    public $key_metadata = null;
 
     public function __construct($vals = null)
     {
@@ -55,7 +56,6 @@ public function __construct($vals = null)
             if (isset($vals['path_in_schema'])) {
                 $this->path_in_schema = $vals['path_in_schema'];
             }
-
             if (isset($vals['key_metadata'])) {
                 $this->key_metadata = $vals['key_metadata'];
             }
@@ -67,6 +67,7 @@ public function getName()
         return 'EncryptionWithColumnKey';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -74,32 +75,27 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::LST) {
-                        $this->path_in_schema = [];
-                        $_size42 = 0;
-                        $_etype45 = 0;
-                        $xfer += $input->readListBegin($_etype45, $_size42);
-
-                        for ($_i46 = 0; $_i46 < $_size42; $_i46++) {
-                            $elem47 = null;
-                            $xfer += $input->readString($elem47);
-                            $this->path_in_schema[] = $elem47;
+                        $this->path_in_schema = array();
+                        $_size49 = 0;
+                        $_etype52 = 0;
+                        $xfer += $input->readListBegin($_etype52, $_size49);
+                        for ($_i53 = 0; $_i53 < $_size49; ++$_i53) {
+                            $elem54 = null;
+                            $xfer += $input->readString($elem54);
+                            $this->path_in_schema []= $elem54;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRING) {
@@ -107,18 +103,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -126,21 +118,18 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('EncryptionWithColumnKey');
-
         if ($this->path_in_schema !== null) {
             if (!is_array($this->path_in_schema)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('path_in_schema', TType::LST, 1);
             $output->writeListBegin(TType::STRING, count($this->path_in_schema));
-
-            foreach ($this->path_in_schema as $iter48) {
-                $xfer += $output->writeString($iter48);
+            foreach ($this->path_in_schema as $iter55) {
+                $xfer += $output->writeString($iter55);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->key_metadata !== null) {
             $xfer += $output->writeFieldBegin('key_metadata', TType::STRING, 2);
             $xfer += $output->writeString($this->key_metadata);
@@ -148,7 +137,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithFooterKey.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithFooterKey.php
index ece9b715d2..a2804f0c81 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithFooterKey.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EncryptionWithFooterKey.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class EncryptionWithFooterKey
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'EncryptionWithFooterKey';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('EncryptionWithFooterKey');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EnumType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EnumType.php
index d51625bcf4..a7ecafb57e 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/EnumType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/EnumType.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class EnumType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'EnumType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('EnumType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FieldRepetitionType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FieldRepetitionType.php
index 041387adb4..71186eb24f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FieldRepetitionType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FieldRepetitionType.php
@@ -1,39 +1,45 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 /**
- * Representation of Schemas.
+ * Representation of Schemas
  */
 final class FieldRepetitionType
 {
     /**
-     * The field is optional (can be null) and each row has 0 or 1 values.
+     * This field is required (can not be null) and each row has exactly 1 value.
      */
-    public const OPTIONAL = 1;
+    const REQUIRED = 0;
 
     /**
-     * The field is repeated and can contain 0 or more values.
+     * The field is optional (can be null) and each row has 0 or 1 values.
      */
-    public const REPEATED = 2;
+    const OPTIONAL = 1;
 
     /**
-     * This field is required (can not be null) and each row has exactly 1 value.
+     * The field is repeated and can contain 0 or more values
      */
-    public const REQUIRED = 0;
+    const REPEATED = 2;
 
-    public static $__names = [
+    static public $__names = array(
         0 => 'REQUIRED',
         1 => 'OPTIONAL',
         2 => 'REPEATED',
-    ];
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileCryptoMetaData.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileCryptoMetaData.php
index 53a398bb1b..72b11e4ce9 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileCryptoMetaData.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileCryptoMetaData.php
@@ -1,56 +1,57 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Crypto metadata for files with encrypted footer *.
+ * Crypto metadata for files with encrypted footer *
  */
 class FileCryptoMetaData
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'encryption_algorithm',
             'isRequired' => true,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\EncryptionAlgorithm',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'key_metadata',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * Encryption algorithm. This field is only used for files
      * with encrypted footer. Files with plaintext footer store algorithm id
      * inside footer (FileMetaData structure).
-     *
-     * @var EncryptionAlgorithm
+     * 
+     * @var \Flow\Parquet\ThriftModel\EncryptionAlgorithm
      */
-    public $encryption_algorithm;
-
+    public $encryption_algorithm = null;
     /**
      * Retrieval metadata of key used for encryption of footer,
-     * and (possibly) columns *.
-     *
-     * @var string
+     * and (possibly) columns *
+     * 
+     * @var null|string
      */
-    public $key_metadata;
+    public $key_metadata = null;
 
     public function __construct($vals = null)
     {
@@ -58,7 +59,6 @@ public function __construct($vals = null)
             if (isset($vals['encryption_algorithm'])) {
                 $this->encryption_algorithm = $vals['encryption_algorithm'];
             }
-
             if (isset($vals['key_metadata'])) {
                 $this->key_metadata = $vals['key_metadata'];
             }
@@ -70,6 +70,7 @@ public function getName()
         return 'FileCryptoMetaData';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -77,23 +78,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->encryption_algorithm = new EncryptionAlgorithm();
+                        $this->encryption_algorithm = new \Flow\Parquet\ThriftModel\EncryptionAlgorithm();
                         $xfer += $this->encryption_algorithm->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRING) {
@@ -101,18 +98,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -120,7 +113,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('FileCryptoMetaData');
-
         if ($this->encryption_algorithm !== null) {
             if (!is_object($this->encryption_algorithm)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -129,7 +121,6 @@ public function write($output)
             $xfer += $this->encryption_algorithm->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->key_metadata !== null) {
             $xfer += $output->writeFieldBegin('key_metadata', TType::STRING, 2);
             $xfer += $output->writeString($this->key_metadata);
@@ -137,7 +128,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileMetaData.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileMetaData.php
index 8c308ebf14..6e4337af40 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileMetaData.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileMetaData.php
@@ -1,180 +1,181 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Description for file metadata.
+ * Description for file metadata
  */
 class FileMetaData
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'version',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'schema',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\SchemaElement',
-            ],
-        ],
-        3 => [
+                ),
+        ),
+        3 => array(
             'var' => 'num_rows',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'row_groups',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\RowGroup',
-            ],
-        ],
-        5 => [
+                ),
+        ),
+        5 => array(
             'var' => 'key_value_metadata',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\KeyValue',
-            ],
-        ],
-        6 => [
+                ),
+        ),
+        6 => array(
             'var' => 'created_by',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'column_orders',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\ColumnOrder',
-            ],
-        ],
-        8 => [
+                ),
+        ),
+        8 => array(
             'var' => 'encryption_algorithm',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\EncryptionAlgorithm',
-        ],
-        9 => [
+        ),
+        9 => array(
             'var' => 'footer_signing_key_metadata',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
+    /**
+     * Version of this file
+     * 
+     * As of December 2025, there is no agreed upon consensus of what constitutes
+     * version 2 of the file. For maximum compatibility with readers, writers should
+     * always populate "1" for version. For maximum compatibility with writers,
+     * readers should accept "1" and "2" interchangeably.  All other versions are
+     * reserved for potential future use-cases.
+     * 
+     * @var int
+     */
+    public $version = null;
+    /**
+     * Parquet schema for this file.  This schema contains metadata for all the columns.
+     * The schema is represented as a tree with a single root.  The nodes of the tree
+     * are flattened to a list by doing a depth-first traversal.
+     * The column metadata contains the path in the schema for that column which can be
+     * used to map columns to nodes in the schema.
+     * The first element is the root *
+     * 
+     * @var \Flow\Parquet\ThriftModel\SchemaElement[]
+     */
+    public $schema = null;
+    /**
+     * Number of rows in this file *
+     * 
+     * @var int
+     */
+    public $num_rows = null;
+    /**
+     * Row groups in this file *
+     * 
+     * @var \Flow\Parquet\ThriftModel\RowGroup[]
+     */
+    public $row_groups = null;
+    /**
+     * Optional key/value metadata *
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\KeyValue[]
+     */
+    public $key_value_metadata = null;
+    /**
+     * String for application that wrote this file.  This should be in the format
+     * <Application> version <App Version> (build <App Build Hash>).
+     * e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55)
+     * 
+     * 
+     * @var null|string
+     */
+    public $created_by = null;
     /**
      * Sort order used for the min_value and max_value fields in the Statistics
      * objects and the min_values and max_values fields in the ColumnIndex
      * objects of each column in this file. Sort orders are listed in the order
-     * matching the columns in the schema. The indexes are not necessary the same
+     * matching the columns in the schema. The indexes are not necessarily the same
      * though, because only leaf nodes of the schema are represented in the list
      * of sort orders.
-     *
+     * 
      * Without column_orders, the meaning of the min_value and max_value fields
      * in the Statistics object and the ColumnIndex object is undefined. To ensure
      * well-defined behaviour, if these fields are written to a Parquet file,
      * column_orders must be written as well.
-     *
+     * 
      * The obsolete min and max fields in the Statistics object are always sorted
      * by signed comparison regardless of column_orders.
-     *
-     * @var array<ColumnOrder>
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\ColumnOrder[]
      */
-    public $column_orders;
-
-    /**
-     * String for application that wrote this file.  This should be in the format
-     * <Application> version <App Version> (build <App Build Hash>).
-     * e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55).
-     *
-     * @var string
-     */
-    public $created_by;
-
+    public $column_orders = null;
     /**
      * Encryption algorithm. This field is set only in encrypted files
      * with plaintext footer. Files with encrypted footer store algorithm id
      * in FileCryptoMetaData structure.
-     *
-     * @var EncryptionAlgorithm
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\EncryptionAlgorithm
      */
-    public $encryption_algorithm;
-
+    public $encryption_algorithm = null;
     /**
      * Retrieval metadata of key used for signing the footer.
      * Used only in encrypted files with plaintext footer.
-     *
-     * @var string
-     */
-    public $footer_signing_key_metadata;
-
-    /**
-     * Optional key/value metadata *.
-     *
-     * @var array<KeyValue>
+     * 
+     * @var null|string
      */
-    public $key_value_metadata;
-
-    /**
-     * Number of rows in this file *.
-     *
-     * @var int
-     */
-    public $num_rows;
-
-    /**
-     * Row groups in this file *.
-     *
-     * @var array<RowGroup>
-     */
-    public $row_groups;
-
-    /**
-     * Parquet schema for this file.  This schema contains metadata for all the columns.
-     * The schema is represented as a tree with a single root.  The nodes of the tree
-     * are flattened to a list by doing a depth-first traversal.
-     * The column metadata contains the path in the schema for that column which can be
-     * used to map columns to nodes in the schema.
-     * The first element is the root *.
-     *
-     * @var array<SchemaElement>
-     */
-    public $schema;
-
-    /**
-     * Version of this file *.
-     *
-     * @var int
-     */
-    public $version;
+    public $footer_signing_key_metadata = null;
 
     public function __construct($vals = null)
     {
@@ -182,35 +183,27 @@ public function __construct($vals = null)
             if (isset($vals['version'])) {
                 $this->version = $vals['version'];
             }
-
             if (isset($vals['schema'])) {
                 $this->schema = $vals['schema'];
             }
-
             if (isset($vals['num_rows'])) {
                 $this->num_rows = $vals['num_rows'];
             }
-
             if (isset($vals['row_groups'])) {
                 $this->row_groups = $vals['row_groups'];
             }
-
             if (isset($vals['key_value_metadata'])) {
                 $this->key_value_metadata = $vals['key_value_metadata'];
             }
-
             if (isset($vals['created_by'])) {
                 $this->created_by = $vals['created_by'];
             }
-
             if (isset($vals['column_orders'])) {
                 $this->column_orders = $vals['column_orders'];
             }
-
             if (isset($vals['encryption_algorithm'])) {
                 $this->encryption_algorithm = $vals['encryption_algorithm'];
             }
-
             if (isset($vals['footer_signing_key_metadata'])) {
                 $this->footer_signing_key_metadata = $vals['footer_signing_key_metadata'];
             }
@@ -222,6 +215,7 @@ public function getName()
         return 'FileMetaData';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -229,14 +223,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -244,26 +235,23 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::LST) {
-                        $this->schema = [];
-                        $_size119 = 0;
-                        $_etype122 = 0;
-                        $xfer += $input->readListBegin($_etype122, $_size119);
-
-                        for ($_i123 = 0; $_i123 < $_size119; $_i123++) {
-                            $elem124 = null;
-                            $elem124 = new SchemaElement();
-                            $xfer += $elem124->read($input);
-                            $this->schema[] = $elem124;
+                        $this->schema = array();
+                        $_size133 = 0;
+                        $_etype136 = 0;
+                        $xfer += $input->readListBegin($_etype136, $_size133);
+                        for ($_i137 = 0; $_i137 < $_size133; ++$_i137) {
+                            $elem138 = null;
+                            $elem138 = new \Flow\Parquet\ThriftModel\SchemaElement();
+                            $xfer += $elem138->read($input);
+                            $this->schema []= $elem138;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I64) {
@@ -271,45 +259,40 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::LST) {
-                        $this->row_groups = [];
-                        $_size125 = 0;
-                        $_etype128 = 0;
-                        $xfer += $input->readListBegin($_etype128, $_size125);
-
-                        for ($_i129 = 0; $_i129 < $_size125; $_i129++) {
-                            $elem130 = null;
-                            $elem130 = new RowGroup();
-                            $xfer += $elem130->read($input);
-                            $this->row_groups[] = $elem130;
+                        $this->row_groups = array();
+                        $_size139 = 0;
+                        $_etype142 = 0;
+                        $xfer += $input->readListBegin($_etype142, $_size139);
+                        for ($_i143 = 0; $_i143 < $_size139; ++$_i143) {
+                            $elem144 = null;
+                            $elem144 = new \Flow\Parquet\ThriftModel\RowGroup();
+                            $xfer += $elem144->read($input);
+                            $this->row_groups []= $elem144;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::LST) {
-                        $this->key_value_metadata = [];
-                        $_size131 = 0;
-                        $_etype134 = 0;
-                        $xfer += $input->readListBegin($_etype134, $_size131);
-
-                        for ($_i135 = 0; $_i135 < $_size131; $_i135++) {
-                            $elem136 = null;
-                            $elem136 = new KeyValue();
-                            $xfer += $elem136->read($input);
-                            $this->key_value_metadata[] = $elem136;
+                        $this->key_value_metadata = array();
+                        $_size145 = 0;
+                        $_etype148 = 0;
+                        $xfer += $input->readListBegin($_etype148, $_size145);
+                        for ($_i149 = 0; $_i149 < $_size145; ++$_i149) {
+                            $elem150 = null;
+                            $elem150 = new \Flow\Parquet\ThriftModel\KeyValue();
+                            $xfer += $elem150->read($input);
+                            $this->key_value_metadata []= $elem150;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::STRING) {
@@ -317,35 +300,31 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::LST) {
-                        $this->column_orders = [];
-                        $_size137 = 0;
-                        $_etype140 = 0;
-                        $xfer += $input->readListBegin($_etype140, $_size137);
-
-                        for ($_i141 = 0; $_i141 < $_size137; $_i141++) {
-                            $elem142 = null;
-                            $elem142 = new ColumnOrder();
-                            $xfer += $elem142->read($input);
-                            $this->column_orders[] = $elem142;
+                        $this->column_orders = array();
+                        $_size151 = 0;
+                        $_etype154 = 0;
+                        $xfer += $input->readListBegin($_etype154, $_size151);
+                        for ($_i155 = 0; $_i155 < $_size151; ++$_i155) {
+                            $elem156 = null;
+                            $elem156 = new \Flow\Parquet\ThriftModel\ColumnOrder();
+                            $xfer += $elem156->read($input);
+                            $this->column_orders []= $elem156;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::STRUCT) {
-                        $this->encryption_algorithm = new EncryptionAlgorithm();
+                        $this->encryption_algorithm = new \Flow\Parquet\ThriftModel\EncryptionAlgorithm();
                         $xfer += $this->encryption_algorithm->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 9:
                     if ($ftype == TType::STRING) {
@@ -353,18 +332,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -372,81 +347,69 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('FileMetaData');
-
         if ($this->version !== null) {
             $xfer += $output->writeFieldBegin('version', TType::I32, 1);
             $xfer += $output->writeI32($this->version);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->schema !== null) {
             if (!is_array($this->schema)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('schema', TType::LST, 2);
             $output->writeListBegin(TType::STRUCT, count($this->schema));
-
-            foreach ($this->schema as $iter143) {
-                $xfer += $iter143->write($output);
+            foreach ($this->schema as $iter157) {
+                $xfer += $iter157->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->num_rows !== null) {
             $xfer += $output->writeFieldBegin('num_rows', TType::I64, 3);
             $xfer += $output->writeI64($this->num_rows);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->row_groups !== null) {
             if (!is_array($this->row_groups)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('row_groups', TType::LST, 4);
             $output->writeListBegin(TType::STRUCT, count($this->row_groups));
-
-            foreach ($this->row_groups as $iter144) {
-                $xfer += $iter144->write($output);
+            foreach ($this->row_groups as $iter158) {
+                $xfer += $iter158->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->key_value_metadata !== null) {
             if (!is_array($this->key_value_metadata)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('key_value_metadata', TType::LST, 5);
             $output->writeListBegin(TType::STRUCT, count($this->key_value_metadata));
-
-            foreach ($this->key_value_metadata as $iter145) {
-                $xfer += $iter145->write($output);
+            foreach ($this->key_value_metadata as $iter159) {
+                $xfer += $iter159->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->created_by !== null) {
             $xfer += $output->writeFieldBegin('created_by', TType::STRING, 6);
             $xfer += $output->writeString($this->created_by);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->column_orders !== null) {
             if (!is_array($this->column_orders)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('column_orders', TType::LST, 7);
             $output->writeListBegin(TType::STRUCT, count($this->column_orders));
-
-            foreach ($this->column_orders as $iter146) {
-                $xfer += $iter146->write($output);
+            foreach ($this->column_orders as $iter160) {
+                $xfer += $iter160->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encryption_algorithm !== null) {
             if (!is_object($this->encryption_algorithm)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -455,7 +418,6 @@ public function write($output)
             $xfer += $this->encryption_algorithm->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->footer_signing_key_metadata !== null) {
             $xfer += $output->writeFieldBegin('footer_signing_key_metadata', TType::STRING, 9);
             $xfer += $output->writeString($this->footer_signing_key_metadata);
@@ -463,7 +425,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileType.php
new file mode 100644
index 0000000000..727d40d337
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/FileType.php
@@ -0,0 +1,76 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * File logical type annotation
+ * 
+ * Annotates a group that represents a reference to a file, or to a range of
+ * bytes that may be stored inline or in an external file.
+ * 
+ * See LogicalTypes.md for details.
+ */
+class FileType
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+    );
+
+
+    public function __construct()
+    {
+    }
+
+    public function getName()
+    {
+        return 'FileType';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('FileType');
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Float16Type.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Float16Type.php
index 510dd4056a..1ccfaee6ff 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Float16Type.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Float16Type.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class Float16Type
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'Float16Type';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('Float16Type');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeographyType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeographyType.php
new file mode 100644
index 0000000000..8c9da6353a
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeographyType.php
@@ -0,0 +1,136 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Embedded Geography logical type annotation
+ * 
+ * Geospatial features in the WKB format with an explicit (non-linear/non-planar)
+ * `edges` interpolation algorithm.
+ * 
+ * A custom geographic CRS can be set by the crs field, where longitudes are
+ * bound by [-180, 180] and latitudes are bound by [-90, 90]. If unset, the CRS
+ * defaults to "OGC:CRS84".
+ * 
+ * An optional algorithm can be set to correctly interpret `edges` interpolation
+ * of the geometries. If unset, the algorithm defaults to SPHERICAL.
+ * 
+ * Allowed for physical type: BYTE_ARRAY.
+ * 
+ * See Geospatial.md for details.
+ */
+class GeographyType
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
+            'var' => 'crs',
+            'isRequired' => false,
+            'type' => TType::STRING,
+        ),
+        2 => array(
+            'var' => 'algorithm',
+            'isRequired' => false,
+            'type' => TType::I32,
+            'class' => '\Flow\Parquet\ThriftModel\EdgeInterpolationAlgorithm',
+        ),
+    );
+
+    /**
+     * @var null|string
+     */
+    public $crs = null;
+    /**
+     * @var null|int
+     */
+    public $algorithm = null;
+
+    public function __construct($vals = null)
+    {
+        if (is_array($vals)) {
+            if (isset($vals['crs'])) {
+                $this->crs = $vals['crs'];
+            }
+            if (isset($vals['algorithm'])) {
+                $this->algorithm = $vals['algorithm'];
+            }
+        }
+    }
+
+    public function getName()
+    {
+        return 'GeographyType';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                case 1:
+                    if ($ftype == TType::STRING) {
+                        $xfer += $input->readString($this->crs);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 2:
+                    if ($ftype == TType::I32) {
+                        $xfer += $input->readI32($this->algorithm);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('GeographyType');
+        if ($this->crs !== null) {
+            $xfer += $output->writeFieldBegin('crs', TType::STRING, 1);
+            $xfer += $output->writeString($this->crs);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->algorithm !== null) {
+            $xfer += $output->writeFieldBegin('algorithm', TType::I32, 2);
+            $xfer += $output->writeI32($this->algorithm);
+            $xfer += $output->writeFieldEnd();
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeometryType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeometryType.php
new file mode 100644
index 0000000000..0d20b548f7
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeometryType.php
@@ -0,0 +1,108 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Embedded Geometry logical type annotation
+ * 
+ * Geospatial features in the Well-Known Binary (WKB) format and `edges` interpolation
+ * is always linear/planar.
+ * 
+ * A custom CRS can be set by the crs field. If unset, it defaults to "OGC:CRS84",
+ * which means that the geometries must be stored in longitude, latitude based on
+ * the WGS84 datum.
+ * 
+ * Allowed for physical type: BYTE_ARRAY.
+ * 
+ * See Geospatial.md for details.
+ */
+class GeometryType
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
+            'var' => 'crs',
+            'isRequired' => false,
+            'type' => TType::STRING,
+        ),
+    );
+
+    /**
+     * @var null|string
+     */
+    public $crs = null;
+
+    public function __construct($vals = null)
+    {
+        if (is_array($vals)) {
+            if (isset($vals['crs'])) {
+                $this->crs = $vals['crs'];
+            }
+        }
+    }
+
+    public function getName()
+    {
+        return 'GeometryType';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                case 1:
+                    if ($ftype == TType::STRING) {
+                        $xfer += $input->readString($this->crs);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('GeometryType');
+        if ($this->crs !== null) {
+            $xfer += $output->writeFieldBegin('crs', TType::STRING, 1);
+            $xfer += $output->writeString($this->crs);
+            $xfer += $output->writeFieldEnd();
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeospatialStatistics.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeospatialStatistics.php
new file mode 100644
index 0000000000..9641fb6cde
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/GeospatialStatistics.php
@@ -0,0 +1,150 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Statistics specific to Geometry and Geography logical types
+ */
+class GeospatialStatistics
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
+            'var' => 'bbox',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\BoundingBox',
+        ),
+        2 => array(
+            'var' => 'geospatial_types',
+            'isRequired' => false,
+            'type' => TType::LST,
+            'etype' => TType::I32,
+            'elem' => array(
+                'type' => TType::I32,
+                ),
+        ),
+    );
+
+    /**
+     * A bounding box of geospatial instances
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\BoundingBox
+     */
+    public $bbox = null;
+    /**
+     * Geospatial type codes of all instances, or an empty list if not known
+     * 
+     * @var null|int[]
+     */
+    public $geospatial_types = null;
+
+    public function __construct($vals = null)
+    {
+        if (is_array($vals)) {
+            if (isset($vals['bbox'])) {
+                $this->bbox = $vals['bbox'];
+            }
+            if (isset($vals['geospatial_types'])) {
+                $this->geospatial_types = $vals['geospatial_types'];
+            }
+        }
+    }
+
+    public function getName()
+    {
+        return 'GeospatialStatistics';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                case 1:
+                    if ($ftype == TType::STRUCT) {
+                        $this->bbox = new \Flow\Parquet\ThriftModel\BoundingBox();
+                        $xfer += $this->bbox->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 2:
+                    if ($ftype == TType::LST) {
+                        $this->geospatial_types = array();
+                        $_size14 = 0;
+                        $_etype17 = 0;
+                        $xfer += $input->readListBegin($_etype17, $_size14);
+                        for ($_i18 = 0; $_i18 < $_size14; ++$_i18) {
+                            $elem19 = null;
+                            $xfer += $input->readI32($elem19);
+                            $this->geospatial_types []= $elem19;
+                        }
+                        $xfer += $input->readListEnd();
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('GeospatialStatistics');
+        if ($this->bbox !== null) {
+            if (!is_object($this->bbox)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('bbox', TType::STRUCT, 1);
+            $xfer += $this->bbox->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->geospatial_types !== null) {
+            if (!is_array($this->geospatial_types)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('geospatial_types', TType::LST, 2);
+            $output->writeListBegin(TType::I32, count($this->geospatial_types));
+            foreach ($this->geospatial_types as $iter20) {
+                $xfer += $output->writeI32($iter20);
+            }
+            $output->writeListEnd();
+            $xfer += $output->writeFieldEnd();
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/IEEE754TotalOrder.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/IEEE754TotalOrder.php
new file mode 100644
index 0000000000..ace62663db
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/IEEE754TotalOrder.php
@@ -0,0 +1,71 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Empty struct to signal IEEE 754 total order for floating point types
+ */
+class IEEE754TotalOrder
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+    );
+
+
+    public function __construct()
+    {
+    }
+
+    public function getName()
+    {
+        return 'IEEE754TotalOrder';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('IEEE754TotalOrder');
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/IndexPageHeader.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/IndexPageHeader.php
index 209be07595..ab44c076f6 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/IndexPageHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/IndexPageHeader.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class IndexPageHeader
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'IndexPageHeader';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('IndexPageHeader');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Int96TimestampOrder.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Int96TimestampOrder.php
new file mode 100644
index 0000000000..21ea29a79e
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Int96TimestampOrder.php
@@ -0,0 +1,71 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Empty struct to signal chronological ordering of physical type INT96
+ */
+class Int96TimestampOrder
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+    );
+
+
+    public function __construct()
+    {
+    }
+
+    public function getName()
+    {
+        return 'Int96TimestampOrder';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('Int96TimestampOrder');
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/IntType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/IntType.php
index 99379feef0..3711ccbe79 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/IntType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/IntType.php
@@ -1,51 +1,53 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Integer logical type annotation.
- *
+ * Integer logical type annotation
+ * 
  * bitWidth must be 8, 16, 32, or 64.
- *
+ * 
  * Allowed for physical types: INT32, INT64
  */
 class IntType
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'bitWidth',
             'isRequired' => true,
             'type' => TType::BYTE,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'isSigned',
             'isRequired' => true,
             'type' => TType::BOOL,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * @var int
      */
-    public $bitWidth;
-
+    public $bitWidth = null;
     /**
      * @var bool
      */
-    public $isSigned;
+    public $isSigned = null;
 
     public function __construct($vals = null)
     {
@@ -53,7 +55,6 @@ public function __construct($vals = null)
             if (isset($vals['bitWidth'])) {
                 $this->bitWidth = $vals['bitWidth'];
             }
-
             if (isset($vals['isSigned'])) {
                 $this->isSigned = $vals['isSigned'];
             }
@@ -65,6 +66,7 @@ public function getName()
         return 'IntType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -72,14 +74,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::BYTE) {
@@ -87,7 +86,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::BOOL) {
@@ -95,18 +93,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -114,13 +108,11 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('IntType');
-
         if ($this->bitWidth !== null) {
             $xfer += $output->writeFieldBegin('bitWidth', TType::BYTE, 1);
             $xfer += $output->writeByte($this->bitWidth);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->isSigned !== null) {
             $xfer += $output->writeFieldBegin('isSigned', TType::BOOL, 2);
             $xfer += $output->writeBool($this->isSigned);
@@ -128,7 +120,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/JsonType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/JsonType.php
index 766c7f2a49..da18861639 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/JsonType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/JsonType.php
@@ -1,36 +1,44 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Embedded JSON logical type annotation.
- *
+ * Embedded JSON logical type annotation
+ * 
  * Allowed for physical types: BYTE_ARRAY
  */
 class JsonType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'JsonType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -38,24 +46,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -65,7 +68,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('JsonType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/KeyValue.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/KeyValue.php
index 3df86a09f0..ab21872389 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/KeyValue.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/KeyValue.php
@@ -1,47 +1,49 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Wrapper struct to store key values.
+ * Wrapper struct to store key values
  */
 class KeyValue
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'key',
             'isRequired' => true,
             'type' => TType::STRING,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'value',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * @var string
      */
-    public $key;
-
+    public $key = null;
     /**
-     * @var string
+     * @var null|string
      */
-    public $value;
+    public $value = null;
 
     public function __construct($vals = null)
     {
@@ -49,7 +51,6 @@ public function __construct($vals = null)
             if (isset($vals['key'])) {
                 $this->key = $vals['key'];
             }
-
             if (isset($vals['value'])) {
                 $this->value = $vals['value'];
             }
@@ -61,6 +62,7 @@ public function getName()
         return 'KeyValue';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -68,14 +70,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRING) {
@@ -83,7 +82,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRING) {
@@ -91,18 +89,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -110,13 +104,11 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('KeyValue');
-
         if ($this->key !== null) {
             $xfer += $output->writeFieldBegin('key', TType::STRING, 1);
             $xfer += $output->writeString($this->key);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->value !== null) {
             $xfer += $output->writeFieldBegin('value', TType::STRING, 2);
             $xfer += $output->writeString($this->value);
@@ -124,7 +116,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ListType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ListType.php
index 071caee557..6045fc45ec 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/ListType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/ListType.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class ListType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'ListType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('ListType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/LogicalType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/LogicalType.php
index 18ba9b0d1c..01634a696b 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/LogicalType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/LogicalType.php
@@ -1,186 +1,215 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * LogicalType annotations to replace ConvertedType.
- *
+ * 
  * To maintain compatibility, implementations using LogicalType for a
  * SchemaElement must also set the corresponding ConvertedType (if any)
  * from the following table.
  */
 class LogicalType
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'STRING',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\StringType',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'MAP',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\MapType',
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'LIST',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\ListType',
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'ENUM',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\EnumType',
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'DECIMAL',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\DecimalType',
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'DATE',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\DateType',
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'TIME',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\TimeType',
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'TIMESTAMP',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\TimestampType',
-        ],
-        10 => [
+        ),
+        10 => array(
             'var' => 'INTEGER',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\IntType',
-        ],
-        11 => [
+        ),
+        11 => array(
             'var' => 'UNKNOWN',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\NullType',
-        ],
-        12 => [
+        ),
+        12 => array(
             'var' => 'JSON',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\JsonType',
-        ],
-        13 => [
+        ),
+        13 => array(
             'var' => 'BSON',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\BsonType',
-        ],
-        14 => [
+        ),
+        14 => array(
             'var' => 'UUID',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\UUIDType',
-        ],
-        15 => [
+        ),
+        15 => array(
             'var' => 'FLOAT16',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\Float16Type',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+        16 => array(
+            'var' => 'VARIANT',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\VariantType',
+        ),
+        17 => array(
+            'var' => 'GEOMETRY',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\GeometryType',
+        ),
+        18 => array(
+            'var' => 'GEOGRAPHY',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\GeographyType',
+        ),
+        19 => array(
+            'var' => 'FILE',
+            'isRequired' => false,
+            'type' => TType::STRUCT,
+            'class' => '\Flow\Parquet\ThriftModel\FileType',
+        ),
+    );
 
     /**
-     * @var BsonType
+     * @var null|\Flow\Parquet\ThriftModel\StringType
      */
-    public $BSON;
-
+    public $STRING = null;
     /**
-     * @var DateType
+     * @var null|\Flow\Parquet\ThriftModel\MapType
      */
-    public $DATE;
-
+    public $MAP = null;
     /**
-     * @var DecimalType
+     * @var null|\Flow\Parquet\ThriftModel\ListType
      */
-    public $DECIMAL;
-
+    public $LIST = null;
     /**
-     * @var EnumType
+     * @var null|\Flow\Parquet\ThriftModel\EnumType
      */
-    public $ENUM;
-
+    public $ENUM = null;
     /**
-     * @var Float16Type
+     * @var null|\Flow\Parquet\ThriftModel\DecimalType
      */
-    public $FLOAT16;
-
+    public $DECIMAL = null;
     /**
-     * @var IntType
+     * @var null|\Flow\Parquet\ThriftModel\DateType
      */
-    public $INTEGER;
-
+    public $DATE = null;
     /**
-     * @var JsonType
+     * @var null|\Flow\Parquet\ThriftModel\TimeType
      */
-    public $JSON;
-
+    public $TIME = null;
     /**
-     * @var ListType
+     * @var null|\Flow\Parquet\ThriftModel\TimestampType
      */
-    public $LIST;
-
+    public $TIMESTAMP = null;
     /**
-     * @var MapType
+     * @var null|\Flow\Parquet\ThriftModel\IntType
      */
-    public $MAP;
-
+    public $INTEGER = null;
     /**
-     * @var StringType
+     * @var null|\Flow\Parquet\ThriftModel\NullType
      */
-    public $STRING;
-
+    public $UNKNOWN = null;
     /**
-     * @var TimeType
+     * @var null|\Flow\Parquet\ThriftModel\JsonType
      */
-    public $TIME;
-
+    public $JSON = null;
     /**
-     * @var TimestampType
+     * @var null|\Flow\Parquet\ThriftModel\BsonType
      */
-    public $TIMESTAMP;
-
+    public $BSON = null;
     /**
-     * @var NullType
+     * @var null|\Flow\Parquet\ThriftModel\UUIDType
      */
-    public $UNKNOWN;
-
+    public $UUID = null;
+    /**
+     * @var null|\Flow\Parquet\ThriftModel\Float16Type
+     */
+    public $FLOAT16 = null;
     /**
-     * @var UUIDType
+     * @var null|\Flow\Parquet\ThriftModel\VariantType
      */
-    public $UUID;
+    public $VARIANT = null;
+    /**
+     * @var null|\Flow\Parquet\ThriftModel\GeometryType
+     */
+    public $GEOMETRY = null;
+    /**
+     * @var null|\Flow\Parquet\ThriftModel\GeographyType
+     */
+    public $GEOGRAPHY = null;
+    /**
+     * @var null|\Flow\Parquet\ThriftModel\FileType
+     */
+    public $FILE = null;
 
     public function __construct($vals = null)
     {
@@ -188,58 +217,57 @@ public function __construct($vals = null)
             if (isset($vals['STRING'])) {
                 $this->STRING = $vals['STRING'];
             }
-
             if (isset($vals['MAP'])) {
                 $this->MAP = $vals['MAP'];
             }
-
             if (isset($vals['LIST'])) {
                 $this->LIST = $vals['LIST'];
             }
-
             if (isset($vals['ENUM'])) {
                 $this->ENUM = $vals['ENUM'];
             }
-
             if (isset($vals['DECIMAL'])) {
                 $this->DECIMAL = $vals['DECIMAL'];
             }
-
             if (isset($vals['DATE'])) {
                 $this->DATE = $vals['DATE'];
             }
-
             if (isset($vals['TIME'])) {
                 $this->TIME = $vals['TIME'];
             }
-
             if (isset($vals['TIMESTAMP'])) {
                 $this->TIMESTAMP = $vals['TIMESTAMP'];
             }
-
             if (isset($vals['INTEGER'])) {
                 $this->INTEGER = $vals['INTEGER'];
             }
-
             if (isset($vals['UNKNOWN'])) {
                 $this->UNKNOWN = $vals['UNKNOWN'];
             }
-
             if (isset($vals['JSON'])) {
                 $this->JSON = $vals['JSON'];
             }
-
             if (isset($vals['BSON'])) {
                 $this->BSON = $vals['BSON'];
             }
-
             if (isset($vals['UUID'])) {
                 $this->UUID = $vals['UUID'];
             }
-
             if (isset($vals['FLOAT16'])) {
                 $this->FLOAT16 = $vals['FLOAT16'];
             }
+            if (isset($vals['VARIANT'])) {
+                $this->VARIANT = $vals['VARIANT'];
+            }
+            if (isset($vals['GEOMETRY'])) {
+                $this->GEOMETRY = $vals['GEOMETRY'];
+            }
+            if (isset($vals['GEOGRAPHY'])) {
+                $this->GEOGRAPHY = $vals['GEOGRAPHY'];
+            }
+            if (isset($vals['FILE'])) {
+                $this->FILE = $vals['FILE'];
+            }
         }
     }
 
@@ -248,6 +276,7 @@ public function getName()
         return 'LogicalType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -255,151 +284,163 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->STRING = new StringType();
+                        $this->STRING = new \Flow\Parquet\ThriftModel\StringType();
                         $xfer += $this->STRING->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->MAP = new MapType();
+                        $this->MAP = new \Flow\Parquet\ThriftModel\MapType();
                         $xfer += $this->MAP->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::STRUCT) {
-                        $this->LIST = new ListType();
+                        $this->LIST = new \Flow\Parquet\ThriftModel\ListType();
                         $xfer += $this->LIST->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::STRUCT) {
-                        $this->ENUM = new EnumType();
+                        $this->ENUM = new \Flow\Parquet\ThriftModel\EnumType();
                         $xfer += $this->ENUM->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::STRUCT) {
-                        $this->DECIMAL = new DecimalType();
+                        $this->DECIMAL = new \Flow\Parquet\ThriftModel\DecimalType();
                         $xfer += $this->DECIMAL->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::STRUCT) {
-                        $this->DATE = new DateType();
+                        $this->DATE = new \Flow\Parquet\ThriftModel\DateType();
                         $xfer += $this->DATE->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::STRUCT) {
-                        $this->TIME = new TimeType();
+                        $this->TIME = new \Flow\Parquet\ThriftModel\TimeType();
                         $xfer += $this->TIME->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::STRUCT) {
-                        $this->TIMESTAMP = new TimestampType();
+                        $this->TIMESTAMP = new \Flow\Parquet\ThriftModel\TimestampType();
                         $xfer += $this->TIMESTAMP->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 10:
                     if ($ftype == TType::STRUCT) {
-                        $this->INTEGER = new IntType();
+                        $this->INTEGER = new \Flow\Parquet\ThriftModel\IntType();
                         $xfer += $this->INTEGER->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 11:
                     if ($ftype == TType::STRUCT) {
-                        $this->UNKNOWN = new NullType();
+                        $this->UNKNOWN = new \Flow\Parquet\ThriftModel\NullType();
                         $xfer += $this->UNKNOWN->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 12:
                     if ($ftype == TType::STRUCT) {
-                        $this->JSON = new JsonType();
+                        $this->JSON = new \Flow\Parquet\ThriftModel\JsonType();
                         $xfer += $this->JSON->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 13:
                     if ($ftype == TType::STRUCT) {
-                        $this->BSON = new BsonType();
+                        $this->BSON = new \Flow\Parquet\ThriftModel\BsonType();
                         $xfer += $this->BSON->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 14:
                     if ($ftype == TType::STRUCT) {
-                        $this->UUID = new UUIDType();
+                        $this->UUID = new \Flow\Parquet\ThriftModel\UUIDType();
                         $xfer += $this->UUID->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 15:
                     if ($ftype == TType::STRUCT) {
-                        $this->FLOAT16 = new Float16Type();
+                        $this->FLOAT16 = new \Flow\Parquet\ThriftModel\Float16Type();
                         $xfer += $this->FLOAT16->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
+                case 16:
+                    if ($ftype == TType::STRUCT) {
+                        $this->VARIANT = new \Flow\Parquet\ThriftModel\VariantType();
+                        $xfer += $this->VARIANT->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 17:
+                    if ($ftype == TType::STRUCT) {
+                        $this->GEOMETRY = new \Flow\Parquet\ThriftModel\GeometryType();
+                        $xfer += $this->GEOMETRY->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 18:
+                    if ($ftype == TType::STRUCT) {
+                        $this->GEOGRAPHY = new \Flow\Parquet\ThriftModel\GeographyType();
+                        $xfer += $this->GEOGRAPHY->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                case 19:
+                    if ($ftype == TType::STRUCT) {
+                        $this->FILE = new \Flow\Parquet\ThriftModel\FileType();
+                        $xfer += $this->FILE->read($input);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -407,7 +448,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('LogicalType');
-
         if ($this->STRING !== null) {
             if (!is_object($this->STRING)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -416,7 +456,6 @@ public function write($output)
             $xfer += $this->STRING->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->MAP !== null) {
             if (!is_object($this->MAP)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -425,7 +464,6 @@ public function write($output)
             $xfer += $this->MAP->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->LIST !== null) {
             if (!is_object($this->LIST)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -434,7 +472,6 @@ public function write($output)
             $xfer += $this->LIST->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->ENUM !== null) {
             if (!is_object($this->ENUM)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -443,7 +480,6 @@ public function write($output)
             $xfer += $this->ENUM->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->DECIMAL !== null) {
             if (!is_object($this->DECIMAL)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -452,7 +488,6 @@ public function write($output)
             $xfer += $this->DECIMAL->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->DATE !== null) {
             if (!is_object($this->DATE)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -461,7 +496,6 @@ public function write($output)
             $xfer += $this->DATE->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->TIME !== null) {
             if (!is_object($this->TIME)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -470,7 +504,6 @@ public function write($output)
             $xfer += $this->TIME->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->TIMESTAMP !== null) {
             if (!is_object($this->TIMESTAMP)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -479,7 +512,6 @@ public function write($output)
             $xfer += $this->TIMESTAMP->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->INTEGER !== null) {
             if (!is_object($this->INTEGER)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -488,7 +520,6 @@ public function write($output)
             $xfer += $this->INTEGER->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->UNKNOWN !== null) {
             if (!is_object($this->UNKNOWN)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -497,7 +528,6 @@ public function write($output)
             $xfer += $this->UNKNOWN->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->JSON !== null) {
             if (!is_object($this->JSON)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -506,7 +536,6 @@ public function write($output)
             $xfer += $this->JSON->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->BSON !== null) {
             if (!is_object($this->BSON)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -515,7 +544,6 @@ public function write($output)
             $xfer += $this->BSON->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->UUID !== null) {
             if (!is_object($this->UUID)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -524,7 +552,6 @@ public function write($output)
             $xfer += $this->UUID->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->FLOAT16 !== null) {
             if (!is_object($this->FLOAT16)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -533,9 +560,40 @@ public function write($output)
             $xfer += $this->FLOAT16->write($output);
             $xfer += $output->writeFieldEnd();
         }
+        if ($this->VARIANT !== null) {
+            if (!is_object($this->VARIANT)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('VARIANT', TType::STRUCT, 16);
+            $xfer += $this->VARIANT->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->GEOMETRY !== null) {
+            if (!is_object($this->GEOMETRY)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('GEOMETRY', TType::STRUCT, 17);
+            $xfer += $this->GEOMETRY->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->GEOGRAPHY !== null) {
+            if (!is_object($this->GEOGRAPHY)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('GEOGRAPHY', TType::STRUCT, 18);
+            $xfer += $this->GEOGRAPHY->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
+        if ($this->FILE !== null) {
+            if (!is_object($this->FILE)) {
+                throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+            }
+            $xfer += $output->writeFieldBegin('FILE', TType::STRUCT, 19);
+            $xfer += $this->FILE->write($output);
+            $xfer += $output->writeFieldEnd();
+        }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/MapType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/MapType.php
index 40021b4e5f..3ac712ef11 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/MapType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/MapType.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class MapType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'MapType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('MapType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/MicroSeconds.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/MicroSeconds.php
index 430bcbe467..a72a175fca 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/MicroSeconds.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/MicroSeconds.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class MicroSeconds
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'MicroSeconds';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('MicroSeconds');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/MilliSeconds.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/MilliSeconds.php
index ebdfaf92cc..76d4a076b3 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/MilliSeconds.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/MilliSeconds.php
@@ -1,34 +1,42 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Time units for logical types.
+ * Time units for logical types
  */
 class MilliSeconds
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'MilliSeconds';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -36,24 +44,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -63,7 +66,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('MilliSeconds');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/NanoSeconds.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/NanoSeconds.php
index 01ce0fa2e2..7dc36800d4 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/NanoSeconds.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/NanoSeconds.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class NanoSeconds
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'NanoSeconds';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('NanoSeconds');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/NullType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/NullType.php
index 47bcbe1a0c..f4a22a713f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/NullType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/NullType.php
@@ -1,38 +1,46 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Logical type to annotate a column that is always null.
- *
+ * 
  * Sometimes when discovering the schema of existing data, values are always
  * null and the physical type can't be determined. This annotation signals
  * the case where the physical type was guessed from all null values.
  */
 class NullType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'NullType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -40,24 +48,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -67,7 +70,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('NullType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/OffsetIndex.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/OffsetIndex.php
index f92716c129..e692218cd4 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/OffsetIndex.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/OffsetIndex.php
@@ -1,69 +1,70 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Optional offsets for each data page in a ColumnChunk.
- *
+ * 
  * Forms part of the page index, along with ColumnIndex.
- *
+ * 
  * OffsetIndex may be present even if ColumnIndex is not.
  */
 class OffsetIndex
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'page_locations',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\PageLocation',
-            ],
-        ],
-        2 => [
+                ),
+        ),
+        2 => array(
             'var' => 'unencoded_byte_array_data_bytes',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::I64,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I64,
-            ],
-        ],
-    ];
-
-    public static $isValidate = false;
+                ),
+        ),
+    );
 
     /**
      * PageLocations, ordered by increasing PageLocation.offset. It is required
      * that page_locations[i].first_row_index < page_locations[i+1].first_row_index.
-     *
-     * @var array<PageLocation>
+     * 
+     * @var \Flow\Parquet\ThriftModel\PageLocation[]
      */
-    public $page_locations;
-
+    public $page_locations = null;
     /**
      * Unencoded/uncompressed size for BYTE_ARRAY types.
-     *
-     * See documention for unencoded_byte_array_data_bytes in SizeStatistics for
+     * 
+     * See documentation for unencoded_byte_array_data_bytes in SizeStatistics for
      * more details on this field.
-     *
-     * @var array<int>
+     * 
+     * @var null|int[]
      */
-    public $unencoded_byte_array_data_bytes;
+    public $unencoded_byte_array_data_bytes = null;
 
     public function __construct($vals = null)
     {
@@ -71,7 +72,6 @@ public function __construct($vals = null)
             if (isset($vals['page_locations'])) {
                 $this->page_locations = $vals['page_locations'];
             }
-
             if (isset($vals['unencoded_byte_array_data_bytes'])) {
                 $this->unencoded_byte_array_data_bytes = $vals['unencoded_byte_array_data_bytes'];
             }
@@ -83,6 +83,7 @@ public function getName()
         return 'OffsetIndex';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -90,62 +91,52 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::LST) {
-                        $this->page_locations = [];
-                        $_size63 = 0;
-                        $_etype66 = 0;
-                        $xfer += $input->readListBegin($_etype66, $_size63);
-
-                        for ($_i67 = 0; $_i67 < $_size63; $_i67++) {
-                            $elem68 = null;
-                            $elem68 = new PageLocation();
-                            $xfer += $elem68->read($input);
-                            $this->page_locations[] = $elem68;
+                        $this->page_locations = array();
+                        $_size70 = 0;
+                        $_etype73 = 0;
+                        $xfer += $input->readListBegin($_etype73, $_size70);
+                        for ($_i74 = 0; $_i74 < $_size70; ++$_i74) {
+                            $elem75 = null;
+                            $elem75 = new \Flow\Parquet\ThriftModel\PageLocation();
+                            $xfer += $elem75->read($input);
+                            $this->page_locations []= $elem75;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::LST) {
-                        $this->unencoded_byte_array_data_bytes = [];
-                        $_size69 = 0;
-                        $_etype72 = 0;
-                        $xfer += $input->readListBegin($_etype72, $_size69);
-
-                        for ($_i73 = 0; $_i73 < $_size69; $_i73++) {
-                            $elem74 = null;
-                            $xfer += $input->readI64($elem74);
-                            $this->unencoded_byte_array_data_bytes[] = $elem74;
+                        $this->unencoded_byte_array_data_bytes = array();
+                        $_size76 = 0;
+                        $_etype79 = 0;
+                        $xfer += $input->readListBegin($_etype79, $_size76);
+                        for ($_i80 = 0; $_i80 < $_size76; ++$_i80) {
+                            $elem81 = null;
+                            $xfer += $input->readI64($elem81);
+                            $this->unencoded_byte_array_data_bytes []= $elem81;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -153,37 +144,32 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('OffsetIndex');
-
         if ($this->page_locations !== null) {
             if (!is_array($this->page_locations)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('page_locations', TType::LST, 1);
             $output->writeListBegin(TType::STRUCT, count($this->page_locations));
-
-            foreach ($this->page_locations as $iter75) {
-                $xfer += $iter75->write($output);
+            foreach ($this->page_locations as $iter82) {
+                $xfer += $iter82->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->unencoded_byte_array_data_bytes !== null) {
             if (!is_array($this->unencoded_byte_array_data_bytes)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('unencoded_byte_array_data_bytes', TType::LST, 2);
             $output->writeListBegin(TType::I64, count($this->unencoded_byte_array_data_bytes));
-
-            foreach ($this->unencoded_byte_array_data_bytes as $iter76) {
-                $xfer += $output->writeI64($iter76);
+            foreach ($this->unencoded_byte_array_data_bytes as $iter83) {
+                $xfer += $output->writeI64($iter83);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageEncodingStats.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageEncodingStats.php
index 15a48a6129..662ec6df8c 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageEncodingStats.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageEncodingStats.php
@@ -1,65 +1,66 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * statistics of a given page type and encoding.
+ * statistics of a given page type and encoding
  */
 class PageEncodingStats
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'page_type',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\PageType',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'encoding',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Encoding',
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'count',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * number of pages of this type with this encoding *.
-     *
+     * the page type (data/dic/...) *
+     * 
      * @var int
      */
-    public $count;
-
+    public $page_type = null;
     /**
-     * encoding of the page *.
-     *
+     * encoding of the page *
+     * 
      * @var int
      */
-    public $encoding;
-
+    public $encoding = null;
     /**
-     * the page type (data/dic/...) *.
-     *
+     * number of pages of this type with this encoding *
+     * 
      * @var int
      */
-    public $page_type;
+    public $count = null;
 
     public function __construct($vals = null)
     {
@@ -67,11 +68,9 @@ public function __construct($vals = null)
             if (isset($vals['page_type'])) {
                 $this->page_type = $vals['page_type'];
             }
-
             if (isset($vals['encoding'])) {
                 $this->encoding = $vals['encoding'];
             }
-
             if (isset($vals['count'])) {
                 $this->count = $vals['count'];
             }
@@ -83,6 +82,7 @@ public function getName()
         return 'PageEncodingStats';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -90,14 +90,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -105,7 +102,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -113,7 +109,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I32) {
@@ -121,18 +116,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -140,19 +131,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('PageEncodingStats');
-
         if ($this->page_type !== null) {
             $xfer += $output->writeFieldBegin('page_type', TType::I32, 1);
             $xfer += $output->writeI32($this->page_type);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->encoding !== null) {
             $xfer += $output->writeFieldBegin('encoding', TType::I32, 2);
             $xfer += $output->writeI32($this->encoding);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->count !== null) {
             $xfer += $output->writeFieldBegin('count', TType::I32, 3);
             $xfer += $output->writeI32($this->count);
@@ -160,7 +148,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageHeader.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageHeader.php
index b6639ab911..3c44feb12d 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageHeader.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageHeader.php
@@ -1,83 +1,96 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class PageHeader
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'type',
             'isRequired' => true,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\PageType',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'uncompressed_page_size',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'compressed_page_size',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'crc',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'data_page_header',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\DataPageHeader',
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'index_page_header',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\IndexPageHeader',
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'dictionary_page_header',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\DictionaryPageHeader',
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'data_page_header_v2',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\DataPageHeaderV2',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Compressed (and potentially encrypted) page size in bytes, not including this header *.
-     *
+     * the type of the page: indicates which of the *_header fields is set *
+     * 
      * @var int
      */
-    public $compressed_page_size;
-
+    public $type = null;
     /**
-     * The 32-bit CRC checksum for the page, to be be calculated as follows:
-     *
+     * Uncompressed page size in bytes (not including this header) *
+     * 
+     * @var int
+     */
+    public $uncompressed_page_size = null;
+    /**
+     * Compressed (and potentially encrypted) page size in bytes, not including this header *
+     * 
+     * @var int
+     */
+    public $compressed_page_size = null;
+    /**
+     * The 32-bit CRC checksum for the page, to be calculated as follows:
+     * 
      * - The standard CRC32 algorithm is used (with polynomial 0x04C11DB7,
-     *   the same as in e.g. GZip).
+     *   the same as in e.g. GZIP).
      * - All page types can have a CRC (v1 and v2 data pages, dictionary pages,
      *   etc.).
      * - The CRC is computed on the serialization binary representation of the page
@@ -87,47 +100,29 @@ class PageHeader
      *   encrypted).
      * - The CRC computation therefore takes place after any compression
      *   and encryption steps, if any.
-     *
+     * 
      * If enabled, this allows for disabling checksumming in HDFS if only a few
      * pages need to be read.
-     *
-     * @var int
+     * 
+     * @var null|int
      */
-    public $crc;
-
-    /**
-     * @var DataPageHeader
-     */
-    public $data_page_header;
-
-    /**
-     * @var DataPageHeaderV2
-     */
-    public $data_page_header_v2;
-
+    public $crc = null;
     /**
-     * @var DictionaryPageHeader
+     * @var null|\Flow\Parquet\ThriftModel\DataPageHeader
      */
-    public $dictionary_page_header;
-
+    public $data_page_header = null;
     /**
-     * @var IndexPageHeader
+     * @var null|\Flow\Parquet\ThriftModel\IndexPageHeader
      */
-    public $index_page_header;
-
+    public $index_page_header = null;
     /**
-     * the type of the page: indicates which of the *_header fields is set *.
-     *
-     * @var int
+     * @var null|\Flow\Parquet\ThriftModel\DictionaryPageHeader
      */
-    public $type;
-
+    public $dictionary_page_header = null;
     /**
-     * Uncompressed page size in bytes (not including this header) *.
-     *
-     * @var int
+     * @var null|\Flow\Parquet\ThriftModel\DataPageHeaderV2
      */
-    public $uncompressed_page_size;
+    public $data_page_header_v2 = null;
 
     public function __construct($vals = null)
     {
@@ -135,31 +130,24 @@ public function __construct($vals = null)
             if (isset($vals['type'])) {
                 $this->type = $vals['type'];
             }
-
             if (isset($vals['uncompressed_page_size'])) {
                 $this->uncompressed_page_size = $vals['uncompressed_page_size'];
             }
-
             if (isset($vals['compressed_page_size'])) {
                 $this->compressed_page_size = $vals['compressed_page_size'];
             }
-
             if (isset($vals['crc'])) {
                 $this->crc = $vals['crc'];
             }
-
             if (isset($vals['data_page_header'])) {
                 $this->data_page_header = $vals['data_page_header'];
             }
-
             if (isset($vals['index_page_header'])) {
                 $this->index_page_header = $vals['index_page_header'];
             }
-
             if (isset($vals['dictionary_page_header'])) {
                 $this->dictionary_page_header = $vals['dictionary_page_header'];
             }
-
             if (isset($vals['data_page_header_v2'])) {
                 $this->data_page_header_v2 = $vals['data_page_header_v2'];
             }
@@ -171,6 +159,7 @@ public function getName()
         return 'PageHeader';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -178,14 +167,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -193,7 +179,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -201,7 +186,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I32) {
@@ -209,7 +193,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I32) {
@@ -217,54 +200,46 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::STRUCT) {
-                        $this->data_page_header = new DataPageHeader();
+                        $this->data_page_header = new \Flow\Parquet\ThriftModel\DataPageHeader();
                         $xfer += $this->data_page_header->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::STRUCT) {
-                        $this->index_page_header = new IndexPageHeader();
+                        $this->index_page_header = new \Flow\Parquet\ThriftModel\IndexPageHeader();
                         $xfer += $this->index_page_header->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::STRUCT) {
-                        $this->dictionary_page_header = new DictionaryPageHeader();
+                        $this->dictionary_page_header = new \Flow\Parquet\ThriftModel\DictionaryPageHeader();
                         $xfer += $this->dictionary_page_header->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::STRUCT) {
-                        $this->data_page_header_v2 = new DataPageHeaderV2();
+                        $this->data_page_header_v2 = new \Flow\Parquet\ThriftModel\DataPageHeaderV2();
                         $xfer += $this->data_page_header_v2->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -272,31 +247,26 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('PageHeader');
-
         if ($this->type !== null) {
             $xfer += $output->writeFieldBegin('type', TType::I32, 1);
             $xfer += $output->writeI32($this->type);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->uncompressed_page_size !== null) {
             $xfer += $output->writeFieldBegin('uncompressed_page_size', TType::I32, 2);
             $xfer += $output->writeI32($this->uncompressed_page_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->compressed_page_size !== null) {
             $xfer += $output->writeFieldBegin('compressed_page_size', TType::I32, 3);
             $xfer += $output->writeI32($this->compressed_page_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->crc !== null) {
             $xfer += $output->writeFieldBegin('crc', TType::I32, 4);
             $xfer += $output->writeI32($this->crc);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->data_page_header !== null) {
             if (!is_object($this->data_page_header)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -305,7 +275,6 @@ public function write($output)
             $xfer += $this->data_page_header->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->index_page_header !== null) {
             if (!is_object($this->index_page_header)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -314,7 +283,6 @@ public function write($output)
             $xfer += $this->index_page_header->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->dictionary_page_header !== null) {
             if (!is_object($this->dictionary_page_header)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -323,7 +291,6 @@ public function write($output)
             $xfer += $this->dictionary_page_header->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->data_page_header_v2 !== null) {
             if (!is_object($this->data_page_header_v2)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -334,7 +301,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageLocation.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageLocation.php
index 120f845ae3..172c2fda6a 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageLocation.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageLocation.php
@@ -1,63 +1,64 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class PageLocation
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'offset',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'compressed_page_size',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'first_row_index',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * Size of the page, including header. Sum of compressed_page_size and header
-     * length.
-     *
+     * Offset of the page in the file *
+     * 
      * @var int
      */
-    public $compressed_page_size;
-
+    public $offset = null;
     /**
-     * Index within the RowGroup of the first row of the page. When an
-     * OffsetIndex is present, pages must begin on row boundaries
-     * (repetition_level = 0).
-     *
+     * Size of the page, including header. Equal to the sum of the page's
+     * PageHeader.compressed_page_size and the size of the serialized PageHeader.
+     * 
      * @var int
      */
-    public $first_row_index;
-
+    public $compressed_page_size = null;
     /**
-     * Offset of the page in the file *.
-     *
+     * Index within the RowGroup of the first row of the page. When an
+     * OffsetIndex is present, pages must begin on row boundaries
+     * (repetition_level = 0).
+     * 
      * @var int
      */
-    public $offset;
+    public $first_row_index = null;
 
     public function __construct($vals = null)
     {
@@ -65,11 +66,9 @@ public function __construct($vals = null)
             if (isset($vals['offset'])) {
                 $this->offset = $vals['offset'];
             }
-
             if (isset($vals['compressed_page_size'])) {
                 $this->compressed_page_size = $vals['compressed_page_size'];
             }
-
             if (isset($vals['first_row_index'])) {
                 $this->first_row_index = $vals['first_row_index'];
             }
@@ -81,6 +80,7 @@ public function getName()
         return 'PageLocation';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -88,14 +88,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I64) {
@@ -103,7 +100,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -111,7 +107,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I64) {
@@ -119,18 +114,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -138,19 +129,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('PageLocation');
-
         if ($this->offset !== null) {
             $xfer += $output->writeFieldBegin('offset', TType::I64, 1);
             $xfer += $output->writeI64($this->offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->compressed_page_size !== null) {
             $xfer += $output->writeFieldBegin('compressed_page_size', TType::I32, 2);
             $xfer += $output->writeI32($this->compressed_page_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->first_row_index !== null) {
             $xfer += $output->writeFieldBegin('first_row_index', TType::I64, 3);
             $xfer += $output->writeI64($this->first_row_index);
@@ -158,7 +146,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageType.php
index d6cacfab6b..71e7370cd0 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/PageType.php
@@ -1,30 +1,36 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 final class PageType
 {
-    public const DATA_PAGE = 0;
+    const DATA_PAGE = 0;
 
-    public const DATA_PAGE_V2 = 3;
+    const INDEX_PAGE = 1;
 
-    public const DICTIONARY_PAGE = 2;
+    const DICTIONARY_PAGE = 2;
 
-    public const INDEX_PAGE = 1;
+    const DATA_PAGE_V2 = 3;
 
-    public static $__names = [
+    static public $__names = array(
         0 => 'DATA_PAGE',
         1 => 'INDEX_PAGE',
         2 => 'DICTIONARY_PAGE',
         3 => 'DATA_PAGE_V2',
-    ];
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/RowGroup.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/RowGroup.php
index ae4c23f498..b701941d94 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/RowGroup.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/RowGroup.php
@@ -1,123 +1,120 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class RowGroup
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'columns',
             'isRequired' => true,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\ColumnChunk',
-            ],
-        ],
-        2 => [
+                ),
+        ),
+        2 => array(
             'var' => 'total_byte_size',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'num_rows',
             'isRequired' => true,
             'type' => TType::I64,
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'sorting_columns',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::STRUCT,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::STRUCT,
                 'class' => '\Flow\Parquet\ThriftModel\SortingColumn',
-            ],
-        ],
-        5 => [
+                ),
+        ),
+        5 => array(
             'var' => 'file_offset',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'total_compressed_size',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'ordinal',
             'isRequired' => false,
             'type' => TType::I16,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * Metadata for each column chunk in this row group.
      * This list must have the same order as the SchemaElement list in FileMetaData.
-     *
-     * @var array<ColumnChunk>
+     * 
+     * 
+     * @var \Flow\Parquet\ThriftModel\ColumnChunk[]
      */
-    public $columns;
-
+    public $columns = null;
     /**
-     * Byte offset from beginning of file to first page (data or dictionary)
-     * in this row group *.
-     *
+     * Total byte size of all the uncompressed column data in this row group *
+     * 
      * @var int
      */
-    public $file_offset;
-
+    public $total_byte_size = null;
     /**
-     * Number of rows in this row group *.
-     *
+     * Number of rows in this row group *
+     * 
      * @var int
      */
-    public $num_rows;
-
-    /**
-     * Row group ordinal in the file *.
-     *
-     * @var int
-     */
-    public $ordinal;
-
+    public $num_rows = null;
     /**
      * If set, specifies a sort ordering of the rows in this RowGroup.
      * The sorting columns can be a subset of all the columns.
-     *
-     * @var array<SortingColumn>
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\SortingColumn[]
      */
-    public $sorting_columns;
-
+    public $sorting_columns = null;
     /**
-     * Total byte size of all the uncompressed column data in this row group *.
-     *
-     * @var int
+     * Byte offset from beginning of file to first page (data or dictionary)
+     * in this row group *
+     * 
+     * @var null|int
      */
-    public $total_byte_size;
-
+    public $file_offset = null;
     /**
      * Total byte size of all compressed (and potentially encrypted) column data
-     * in this row group *.
-     *
-     * @var int
+     * in this row group *
+     * 
+     * @var null|int
      */
-    public $total_compressed_size;
+    public $total_compressed_size = null;
+    /**
+     * Row group ordinal in the file *
+     * 
+     * @var null|int
+     */
+    public $ordinal = null;
 
     public function __construct($vals = null)
     {
@@ -125,27 +122,21 @@ public function __construct($vals = null)
             if (isset($vals['columns'])) {
                 $this->columns = $vals['columns'];
             }
-
             if (isset($vals['total_byte_size'])) {
                 $this->total_byte_size = $vals['total_byte_size'];
             }
-
             if (isset($vals['num_rows'])) {
                 $this->num_rows = $vals['num_rows'];
             }
-
             if (isset($vals['sorting_columns'])) {
                 $this->sorting_columns = $vals['sorting_columns'];
             }
-
             if (isset($vals['file_offset'])) {
                 $this->file_offset = $vals['file_offset'];
             }
-
             if (isset($vals['total_compressed_size'])) {
                 $this->total_compressed_size = $vals['total_compressed_size'];
             }
-
             if (isset($vals['ordinal'])) {
                 $this->ordinal = $vals['ordinal'];
             }
@@ -157,6 +148,7 @@ public function getName()
         return 'RowGroup';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -164,33 +156,28 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::LST) {
-                        $this->columns = [];
-                        $_size49 = 0;
-                        $_etype52 = 0;
-                        $xfer += $input->readListBegin($_etype52, $_size49);
-
-                        for ($_i53 = 0; $_i53 < $_size49; $_i53++) {
-                            $elem54 = null;
-                            $elem54 = new ColumnChunk();
-                            $xfer += $elem54->read($input);
-                            $this->columns[] = $elem54;
+                        $this->columns = array();
+                        $_size56 = 0;
+                        $_etype59 = 0;
+                        $xfer += $input->readListBegin($_etype59, $_size56);
+                        for ($_i60 = 0; $_i60 < $_size56; ++$_i60) {
+                            $elem61 = null;
+                            $elem61 = new \Flow\Parquet\ThriftModel\ColumnChunk();
+                            $xfer += $elem61->read($input);
+                            $this->columns []= $elem61;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I64) {
@@ -198,7 +185,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I64) {
@@ -206,26 +192,23 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::LST) {
-                        $this->sorting_columns = [];
-                        $_size55 = 0;
-                        $_etype58 = 0;
-                        $xfer += $input->readListBegin($_etype58, $_size55);
-
-                        for ($_i59 = 0; $_i59 < $_size55; $_i59++) {
-                            $elem60 = null;
-                            $elem60 = new SortingColumn();
-                            $xfer += $elem60->read($input);
-                            $this->sorting_columns[] = $elem60;
+                        $this->sorting_columns = array();
+                        $_size62 = 0;
+                        $_etype65 = 0;
+                        $xfer += $input->readListBegin($_etype65, $_size62);
+                        for ($_i66 = 0; $_i66 < $_size62; ++$_i66) {
+                            $elem67 = null;
+                            $elem67 = new \Flow\Parquet\ThriftModel\SortingColumn();
+                            $xfer += $elem67->read($input);
+                            $this->sorting_columns []= $elem67;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::I64) {
@@ -233,7 +216,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::I64) {
@@ -241,7 +223,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::I16) {
@@ -249,18 +230,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -268,59 +245,50 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('RowGroup');
-
         if ($this->columns !== null) {
             if (!is_array($this->columns)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('columns', TType::LST, 1);
             $output->writeListBegin(TType::STRUCT, count($this->columns));
-
-            foreach ($this->columns as $iter61) {
-                $xfer += $iter61->write($output);
+            foreach ($this->columns as $iter68) {
+                $xfer += $iter68->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->total_byte_size !== null) {
             $xfer += $output->writeFieldBegin('total_byte_size', TType::I64, 2);
             $xfer += $output->writeI64($this->total_byte_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->num_rows !== null) {
             $xfer += $output->writeFieldBegin('num_rows', TType::I64, 3);
             $xfer += $output->writeI64($this->num_rows);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->sorting_columns !== null) {
             if (!is_array($this->sorting_columns)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('sorting_columns', TType::LST, 4);
             $output->writeListBegin(TType::STRUCT, count($this->sorting_columns));
-
-            foreach ($this->sorting_columns as $iter62) {
-                $xfer += $iter62->write($output);
+            foreach ($this->sorting_columns as $iter69) {
+                $xfer += $iter69->write($output);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->file_offset !== null) {
             $xfer += $output->writeFieldBegin('file_offset', TType::I64, 5);
             $xfer += $output->writeI64($this->file_offset);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->total_compressed_size !== null) {
             $xfer += $output->writeFieldBegin('total_compressed_size', TType::I64, 6);
             $xfer += $output->writeI64($this->total_compressed_size);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->ordinal !== null) {
             $xfer += $output->writeFieldBegin('ordinal', TType::I16, 7);
             $xfer += $output->writeI16($this->ordinal);
@@ -328,7 +296,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SchemaElement.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SchemaElement.php
index 525e6014f3..c4312d6c4e 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SchemaElement.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SchemaElement.php
@@ -1,170 +1,163 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Represents a element inside a schema definition.
+ * Represents an element inside a schema definition.
  *  - if it is a group (inner node) then type is undefined and num_children is defined
  *  - if it is a primitive type (leaf) then type is defined and num_children is undefined
  * the nodes are listed in depth first traversal order.
  */
 class SchemaElement
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'type',
             'isRequired' => false,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\Type',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'type_length',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'repetition_type',
             'isRequired' => false,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\FieldRepetitionType',
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'name',
             'isRequired' => true,
             'type' => TType::STRING,
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'num_children',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'converted_type',
             'isRequired' => false,
             'type' => TType::I32,
             'class' => '\Flow\Parquet\ThriftModel\ConvertedType',
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'scale',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'precision',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        9 => [
+        ),
+        9 => array(
             'var' => 'field_id',
             'isRequired' => false,
             'type' => TType::I32,
-        ],
-        10 => [
+        ),
+        10 => array(
             'var' => 'logicalType',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\LogicalType',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * DEPRECATED: When the schema is the result of a conversion from another model.
-     * Used to record the original type to help with cross conversion.
-     *
-     * This is superseded by logicalType.
-     *
-     * @var int
+     * Data type for this field. Not set if the current element is a non-leaf node
+     * 
+     * @var null|int
      */
-    public $converted_type;
-
+    public $type = null;
     /**
-     * When the original schema supports field ids, this will save the
-     * original field id in the parquet schema.
-     *
-     * @var int
+     * If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values.
+     * Otherwise, if specified, this is the maximum bit length to store any of the values.
+     * (e.g. a low cardinality INT col could have this set to 3).  Note that this is
+     * in the schema, and therefore fixed for the entire file.
+     * 
+     * @var null|int
      */
-    public $field_id;
-
+    public $type_length = null;
     /**
-     * The logical type of this SchemaElement.
-     *
-     * LogicalType replaces ConvertedType, but ConvertedType is still required
-     * for some logical types to ensure forward-compatibility in format v1.
-     *
-     * @var LogicalType
+     * repetition of the field. The root of the schema does not have a repetition_type.
+     * All other nodes must have one
+     * 
+     * @var null|int
      */
-    public $logicalType;
-
+    public $repetition_type = null;
     /**
-     * Name of the field in the schema.
-     *
+     * Name of the field in the schema
+     * 
      * @var string
      */
-    public $name;
-
+    public $name = null;
     /**
      * Nested fields.  Since thrift does not support nested fields,
      * the nesting is flattened to a single list by a depth-first traversal.
      * The children count is used to construct the nested relationship.
-     * This field is not set when the element is a primitive type.
-     *
-     * @var int
-     */
-    public $num_children;
-
-    /**
-     * @var int
+     * This field is not set when the element is a primitive type
+     * 
+     * @var null|int
      */
-    public $precision;
-
+    public $num_children = null;
     /**
-     * repetition of the field. The root of the schema does not have a repetition_type.
-     * All other nodes must have one.
-     *
-     * @var int
+     * DEPRECATED: When the schema is the result of a conversion from another model.
+     * Used to record the original type to help with cross conversion.
+     * 
+     * This is superseded by logicalType.
+     * 
+     * @var null|int
      */
-    public $repetition_type;
-
+    public $converted_type = null;
     /**
      * DEPRECATED: Used when this column contains decimal data.
      * See the DECIMAL converted type for more details.
-     *
+     * 
      * This is superseded by using the DecimalType annotation in logicalType.
-     *
-     * @var int
+     * 
+     * @var null|int
      */
-    public $scale;
-
+    public $scale = null;
     /**
-     * Data type for this field. Not set if the current element is a non-leaf node.
-     *
-     * @var int
+     * @var null|int
      */
-    public $type;
-
+    public $precision = null;
     /**
-     * If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values.
-     * Otherwise, if specified, this is the maximum bit length to store any of the values.
-     * (e.g. a low cardinality INT col could have this set to 3).  Note that this is
-     * in the schema, and therefore fixed for the entire file.
-     *
-     * @var int
+     * When the original schema supports field ids, this will save the
+     * original field id in the parquet schema
+     * 
+     * @var null|int
      */
-    public $type_length;
+    public $field_id = null;
+    /**
+     * The logical type of this SchemaElement
+     * 
+     * LogicalType replaces ConvertedType, but ConvertedType is still required
+     * for some logical types to ensure forward-compatibility in format v1.
+     * 
+     * @var null|\Flow\Parquet\ThriftModel\LogicalType
+     */
+    public $logicalType = null;
 
     public function __construct($vals = null)
     {
@@ -172,39 +165,30 @@ public function __construct($vals = null)
             if (isset($vals['type'])) {
                 $this->type = $vals['type'];
             }
-
             if (isset($vals['type_length'])) {
                 $this->type_length = $vals['type_length'];
             }
-
             if (isset($vals['repetition_type'])) {
                 $this->repetition_type = $vals['repetition_type'];
             }
-
             if (isset($vals['name'])) {
                 $this->name = $vals['name'];
             }
-
             if (isset($vals['num_children'])) {
                 $this->num_children = $vals['num_children'];
             }
-
             if (isset($vals['converted_type'])) {
                 $this->converted_type = $vals['converted_type'];
             }
-
             if (isset($vals['scale'])) {
                 $this->scale = $vals['scale'];
             }
-
             if (isset($vals['precision'])) {
                 $this->precision = $vals['precision'];
             }
-
             if (isset($vals['field_id'])) {
                 $this->field_id = $vals['field_id'];
             }
-
             if (isset($vals['logicalType'])) {
                 $this->logicalType = $vals['logicalType'];
             }
@@ -216,6 +200,7 @@ public function getName()
         return 'SchemaElement';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -223,14 +208,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -238,7 +220,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::I32) {
@@ -246,7 +227,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I32) {
@@ -254,7 +234,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::STRING) {
@@ -262,7 +241,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::I32) {
@@ -270,7 +248,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::I32) {
@@ -278,7 +255,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::I32) {
@@ -286,7 +262,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::I32) {
@@ -294,7 +269,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 9:
                     if ($ftype == TType::I32) {
@@ -302,27 +276,22 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 10:
                     if ($ftype == TType::STRUCT) {
-                        $this->logicalType = new LogicalType();
+                        $this->logicalType = new \Flow\Parquet\ThriftModel\LogicalType();
                         $xfer += $this->logicalType->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -330,61 +299,51 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('SchemaElement');
-
         if ($this->type !== null) {
             $xfer += $output->writeFieldBegin('type', TType::I32, 1);
             $xfer += $output->writeI32($this->type);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->type_length !== null) {
             $xfer += $output->writeFieldBegin('type_length', TType::I32, 2);
             $xfer += $output->writeI32($this->type_length);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->repetition_type !== null) {
             $xfer += $output->writeFieldBegin('repetition_type', TType::I32, 3);
             $xfer += $output->writeI32($this->repetition_type);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->name !== null) {
             $xfer += $output->writeFieldBegin('name', TType::STRING, 4);
             $xfer += $output->writeString($this->name);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->num_children !== null) {
             $xfer += $output->writeFieldBegin('num_children', TType::I32, 5);
             $xfer += $output->writeI32($this->num_children);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->converted_type !== null) {
             $xfer += $output->writeFieldBegin('converted_type', TType::I32, 6);
             $xfer += $output->writeI32($this->converted_type);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->scale !== null) {
             $xfer += $output->writeFieldBegin('scale', TType::I32, 7);
             $xfer += $output->writeI32($this->scale);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->precision !== null) {
             $xfer += $output->writeFieldBegin('precision', TType::I32, 8);
             $xfer += $output->writeI32($this->precision);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->field_id !== null) {
             $xfer += $output->writeFieldBegin('field_id', TType::I32, 9);
             $xfer += $output->writeI32($this->field_id);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->logicalType !== null) {
             if (!is_object($this->logicalType)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -395,7 +354,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SizeStatistics.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SizeStatistics.php
index 7eb8f9c07e..1718318282 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SizeStatistics.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SizeStatistics.php
@@ -1,18 +1,20 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * A structure for capturing metadata for estimating the unencoded,
@@ -24,56 +26,33 @@
  */
 class SizeStatistics
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'unencoded_byte_array_data_bytes',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'repetition_level_histogram',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::I64,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I64,
-            ],
-        ],
-        3 => [
+                ),
+        ),
+        3 => array(
             'var' => 'definition_level_histogram',
             'isRequired' => false,
             'type' => TType::LST,
             'etype' => TType::I64,
-            'elem' => [
+            'elem' => array(
                 'type' => TType::I64,
-            ],
-        ],
-    ];
-
-    public static $isValidate = false;
-
-    /**
-     * Same as repetition_level_histogram except for definition levels.
-     *
-     * This field may be omitted if max_definition_level is 0 or 1 without
-     * loss of information.
-     *
-     * @var array<int>
-     */
-    public $definition_level_histogram;
-
-    /**
-     * When present, there is expected to be one element corresponding to each
-     * repetition (i.e. size=max repetition_level+1) where each element
-     * represents the number of times the repetition level was observed in the
-     * data.
-     *
-     * This field may be omitted if max_repetition_level is 0 without loss
-     * of information.
-     *
-     * @var array<int>
-     */
-    public $repetition_level_histogram;
+                ),
+        ),
+    );
 
     /**
      * The number of physical bytes stored for BYTE_ARRAY data values assuming
@@ -84,17 +63,40 @@ class SizeStatistics
      * schema information multiplied by the number of non-null and null values.
      * The number of null/non-null values can be inferred from the histograms
      * below.
-     *
+     * 
      * For example, if a column chunk is dictionary-encoded with dictionary
      * ["a", "bc", "cde"], and a data page contains the indices [0, 0, 1, 2],
      * then this value for that data page should be 7 (1 + 1 + 2 + 3).
-     *
+     * 
      * This field should only be set for types that use BYTE_ARRAY as their
      * physical type.
-     *
-     * @var int
+     * 
+     * @var null|int
      */
-    public $unencoded_byte_array_data_bytes;
+    public $unencoded_byte_array_data_bytes = null;
+    /**
+     * When present, there is expected to be one element corresponding to each
+     * repetition (i.e. size=max repetition_level+1) where each element
+     * represents the number of times the repetition level was observed in the
+     * data.
+     * 
+     * This field may be omitted if max_repetition_level is 0 without loss
+     * of information.
+     * 
+     * 
+     * @var null|int[]
+     */
+    public $repetition_level_histogram = null;
+    /**
+     * Same as repetition_level_histogram except for definition levels.
+     * 
+     * This field may be omitted if max_definition_level is 0 or 1 without
+     * loss of information.
+     * 
+     * 
+     * @var null|int[]
+     */
+    public $definition_level_histogram = null;
 
     public function __construct($vals = null)
     {
@@ -102,11 +104,9 @@ public function __construct($vals = null)
             if (isset($vals['unencoded_byte_array_data_bytes'])) {
                 $this->unencoded_byte_array_data_bytes = $vals['unencoded_byte_array_data_bytes'];
             }
-
             if (isset($vals['repetition_level_histogram'])) {
                 $this->repetition_level_histogram = $vals['repetition_level_histogram'];
             }
-
             if (isset($vals['definition_level_histogram'])) {
                 $this->definition_level_histogram = $vals['definition_level_histogram'];
             }
@@ -118,6 +118,7 @@ public function getName()
         return 'SizeStatistics';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -125,14 +126,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I64) {
@@ -140,54 +138,46 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::LST) {
-                        $this->repetition_level_histogram = [];
+                        $this->repetition_level_histogram = array();
                         $_size0 = 0;
                         $_etype3 = 0;
                         $xfer += $input->readListBegin($_etype3, $_size0);
-
-                        for ($_i4 = 0; $_i4 < $_size0; $_i4++) {
+                        for ($_i4 = 0; $_i4 < $_size0; ++$_i4) {
                             $elem5 = null;
                             $xfer += $input->readI64($elem5);
-                            $this->repetition_level_histogram[] = $elem5;
+                            $this->repetition_level_histogram []= $elem5;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::LST) {
-                        $this->definition_level_histogram = [];
+                        $this->definition_level_histogram = array();
                         $_size6 = 0;
                         $_etype9 = 0;
                         $xfer += $input->readListBegin($_etype9, $_size6);
-
-                        for ($_i10 = 0; $_i10 < $_size6; $_i10++) {
+                        for ($_i10 = 0; $_i10 < $_size6; ++$_i10) {
                             $elem11 = null;
                             $xfer += $input->readI64($elem11);
-                            $this->definition_level_histogram[] = $elem11;
+                            $this->definition_level_histogram []= $elem11;
                         }
                         $xfer += $input->readListEnd();
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -195,34 +185,29 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('SizeStatistics');
-
         if ($this->unencoded_byte_array_data_bytes !== null) {
             $xfer += $output->writeFieldBegin('unencoded_byte_array_data_bytes', TType::I64, 1);
             $xfer += $output->writeI64($this->unencoded_byte_array_data_bytes);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->repetition_level_histogram !== null) {
             if (!is_array($this->repetition_level_histogram)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('repetition_level_histogram', TType::LST, 2);
             $output->writeListBegin(TType::I64, count($this->repetition_level_histogram));
-
             foreach ($this->repetition_level_histogram as $iter12) {
                 $xfer += $output->writeI64($iter12);
             }
             $output->writeListEnd();
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->definition_level_histogram !== null) {
             if (!is_array($this->definition_level_histogram)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
             }
             $xfer += $output->writeFieldBegin('definition_level_histogram', TType::LST, 3);
             $output->writeListBegin(TType::I64, count($this->definition_level_histogram));
-
             foreach ($this->definition_level_histogram as $iter13) {
                 $xfer += $output->writeI64($iter13);
             }
@@ -231,7 +216,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SortingColumn.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SortingColumn.php
index c8739a65b5..c1830b0b2f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SortingColumn.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SortingColumn.php
@@ -1,64 +1,65 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Sort order within a RowGroup of a leaf column.
+ * Sort order within a RowGroup of a leaf column
  */
 class SortingColumn
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'column_idx',
             'isRequired' => true,
             'type' => TType::I32,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'descending',
             'isRequired' => true,
             'type' => TType::BOOL,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'nulls_first',
             'isRequired' => true,
             'type' => TType::BOOL,
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * The ordinal position of the column (in this row group) *.
-     *
+     * The ordinal position of the column (in this row group) *
+     * 
      * @var int
      */
-    public $column_idx;
-
+    public $column_idx = null;
     /**
-     * If true, indicates this column is sorted in descending order. *.
-     *
+     * If true, indicates this column is sorted in descending order. *
+     * 
      * @var bool
      */
-    public $descending;
-
+    public $descending = null;
     /**
      * If true, nulls will come before non-null values, otherwise,
      * nulls go at the end.
-     *
+     * 
      * @var bool
      */
-    public $nulls_first;
+    public $nulls_first = null;
 
     public function __construct($vals = null)
     {
@@ -66,11 +67,9 @@ public function __construct($vals = null)
             if (isset($vals['column_idx'])) {
                 $this->column_idx = $vals['column_idx'];
             }
-
             if (isset($vals['descending'])) {
                 $this->descending = $vals['descending'];
             }
-
             if (isset($vals['nulls_first'])) {
                 $this->nulls_first = $vals['nulls_first'];
             }
@@ -82,6 +81,7 @@ public function getName()
         return 'SortingColumn';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -89,14 +89,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::I32) {
@@ -104,7 +101,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::BOOL) {
@@ -112,7 +108,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::BOOL) {
@@ -120,18 +115,14 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -139,19 +130,16 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('SortingColumn');
-
         if ($this->column_idx !== null) {
             $xfer += $output->writeFieldBegin('column_idx', TType::I32, 1);
             $xfer += $output->writeI32($this->column_idx);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->descending !== null) {
             $xfer += $output->writeFieldBegin('descending', TType::BOOL, 2);
             $xfer += $output->writeBool($this->descending);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->nulls_first !== null) {
             $xfer += $output->writeFieldBegin('nulls_first', TType::BOOL, 3);
             $xfer += $output->writeBool($this->nulls_first);
@@ -159,7 +147,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SplitBlockAlgorithm.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SplitBlockAlgorithm.php
index b5684076d1..6ccb3f37a3 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/SplitBlockAlgorithm.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/SplitBlockAlgorithm.php
@@ -1,34 +1,42 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Block-based algorithm type annotation. *.
+ * Block-based algorithm type annotation. *
  */
 class SplitBlockAlgorithm
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'SplitBlockAlgorithm';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -36,24 +44,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -63,7 +66,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('SplitBlockAlgorithm');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Statistics.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Statistics.php
index fb59491d33..d693714315 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Statistics.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Statistics.php
@@ -1,17 +1,20 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Statistics per row group and per page
@@ -19,126 +22,133 @@
  */
 class Statistics
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'max',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'min',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'null_count',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        4 => [
+        ),
+        4 => array(
             'var' => 'distinct_count',
             'isRequired' => false,
             'type' => TType::I64,
-        ],
-        5 => [
+        ),
+        5 => array(
             'var' => 'max_value',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        6 => [
+        ),
+        6 => array(
             'var' => 'min_value',
             'isRequired' => false,
             'type' => TType::STRING,
-        ],
-        7 => [
+        ),
+        7 => array(
             'var' => 'is_max_value_exact',
             'isRequired' => false,
             'type' => TType::BOOL,
-        ],
-        8 => [
+        ),
+        8 => array(
             'var' => 'is_min_value_exact',
             'isRequired' => false,
             'type' => TType::BOOL,
-        ],
-    ];
-
-    public static $isValidate = false;
-
-    /**
-     * count of distinct values occurring.
-     *
-     * @var int
-     */
-    public $distinct_count;
-
-    /**
-     * If true, max_value is the actual maximum value for a column.
-     *
-     * @var bool
-     */
-    public $is_max_value_exact;
-
-    /**
-     * If true, min_value is the actual minimum value for a column.
-     *
-     * @var bool
-     */
-    public $is_min_value_exact;
+        ),
+        9 => array(
+            'var' => 'nan_count',
+            'isRequired' => false,
+            'type' => TType::I64,
+        ),
+    );
 
     /**
      * DEPRECATED: min and max value of the column. Use min_value and max_value.
-     *
+     * 
      * Values are encoded using PLAIN encoding, except that variable-length byte
      * arrays do not include a length prefix.
-     *
+     * 
      * These fields encode min and max values determined by signed comparison
      * only. New files should use the correct order for a column's logical type
      * and store the values in the min_value and max_value fields.
-     *
+     * 
      * To support older readers, these may be set when the column order is
      * signed.
-     *
-     * @var string
+     * 
+     * @var null|string
      */
-    public $max;
-
+    public $max = null;
+    /**
+     * @var null|string
+     */
+    public $min = null;
+    /**
+     * Count of null values in the column.
+     * 
+     * Writers SHOULD always write this field even if it is zero (i.e. no null value)
+     * or the column is not nullable.
+     * Readers MUST distinguish between null_count not being present and null_count == 0.
+     * If null_count is not present, readers MUST NOT assume null_count == 0.
+     * 
+     * @var null|int
+     */
+    public $null_count = null;
+    /**
+     * count of distinct values occurring
+     * 
+     * @var null|int
+     */
+    public $distinct_count = null;
     /**
      * Lower and upper bound values for the column, determined by its ColumnOrder.
-     *
+     * 
      * These may be the actual minimum and maximum values found on a page or column
      * chunk, but can also be (more compact) values that do not exist on a page or
      * column chunk. For example, instead of storing "Blart Versenwald III", a writer
      * may set min_value="B", max_value="C". Such more compact values must still be
      * valid values within the column's logical type.
-     *
+     * 
      * Values are encoded using PLAIN encoding, except that variable-length byte
      * arrays do not include a length prefix.
-     *
-     * @var string
+     * 
+     * @var null|string
      */
-    public $max_value;
-
+    public $max_value = null;
     /**
-     * @var string
+     * @var null|string
      */
-    public $min;
-
+    public $min_value = null;
     /**
-     * @var string
+     * If true, max_value is the actual maximum value for a column
+     * 
+     * @var null|bool
      */
-    public $min_value;
-
+    public $is_max_value_exact = null;
     /**
-     * Count of null values in the column.
-     *
-     * Writers SHOULD always write this field even if it is zero (i.e. no null value)
-     * or the column is not nullable.
-     * Readers MUST distinguish between null_count not being present and null_count == 0.
-     * If null_count is not present, readers MUST NOT assume null_count == 0.
-     *
-     * @var int
+     * If true, min_value is the actual minimum value for a column
+     * 
+     * @var null|bool
+     */
+    public $is_min_value_exact = null;
+    /**
+     * Count of NaN values in the column; only present if physical type is FLOAT
+     * or DOUBLE, or logical type is FLOAT16.
+     * If this field is not present, readers MUST assume NaNs may be present
+     * (i.e. MUST assume nan_count > 0 and MAY NOT assume nan_count == 0).
+     * 
+     * @var null|int
      */
-    public $null_count;
+    public $nan_count = null;
 
     public function __construct($vals = null)
     {
@@ -146,34 +156,30 @@ public function __construct($vals = null)
             if (isset($vals['max'])) {
                 $this->max = $vals['max'];
             }
-
             if (isset($vals['min'])) {
                 $this->min = $vals['min'];
             }
-
             if (isset($vals['null_count'])) {
                 $this->null_count = $vals['null_count'];
             }
-
             if (isset($vals['distinct_count'])) {
                 $this->distinct_count = $vals['distinct_count'];
             }
-
             if (isset($vals['max_value'])) {
                 $this->max_value = $vals['max_value'];
             }
-
             if (isset($vals['min_value'])) {
                 $this->min_value = $vals['min_value'];
             }
-
             if (isset($vals['is_max_value_exact'])) {
                 $this->is_max_value_exact = $vals['is_max_value_exact'];
             }
-
             if (isset($vals['is_min_value_exact'])) {
                 $this->is_min_value_exact = $vals['is_min_value_exact'];
             }
+            if (isset($vals['nan_count'])) {
+                $this->nan_count = $vals['nan_count'];
+            }
         }
     }
 
@@ -182,6 +188,7 @@ public function getName()
         return 'Statistics';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -189,14 +196,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRING) {
@@ -204,7 +208,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRING) {
@@ -212,7 +215,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::I64) {
@@ -220,7 +222,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 4:
                     if ($ftype == TType::I64) {
@@ -228,7 +229,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 5:
                     if ($ftype == TType::STRING) {
@@ -236,7 +236,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 6:
                     if ($ftype == TType::STRING) {
@@ -244,7 +243,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 7:
                     if ($ftype == TType::BOOL) {
@@ -252,7 +250,6 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 8:
                     if ($ftype == TType::BOOL) {
@@ -260,18 +257,21 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
+                case 9:
+                    if ($ftype == TType::I64) {
+                        $xfer += $input->readI64($this->nan_count);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -279,57 +279,53 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('Statistics');
-
         if ($this->max !== null) {
             $xfer += $output->writeFieldBegin('max', TType::STRING, 1);
             $xfer += $output->writeString($this->max);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->min !== null) {
             $xfer += $output->writeFieldBegin('min', TType::STRING, 2);
             $xfer += $output->writeString($this->min);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->null_count !== null) {
             $xfer += $output->writeFieldBegin('null_count', TType::I64, 3);
             $xfer += $output->writeI64($this->null_count);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->distinct_count !== null) {
             $xfer += $output->writeFieldBegin('distinct_count', TType::I64, 4);
             $xfer += $output->writeI64($this->distinct_count);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->max_value !== null) {
             $xfer += $output->writeFieldBegin('max_value', TType::STRING, 5);
             $xfer += $output->writeString($this->max_value);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->min_value !== null) {
             $xfer += $output->writeFieldBegin('min_value', TType::STRING, 6);
             $xfer += $output->writeString($this->min_value);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->is_max_value_exact !== null) {
             $xfer += $output->writeFieldBegin('is_max_value_exact', TType::BOOL, 7);
             $xfer += $output->writeBool($this->is_max_value_exact);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->is_min_value_exact !== null) {
             $xfer += $output->writeFieldBegin('is_min_value_exact', TType::BOOL, 8);
             $xfer += $output->writeBool($this->is_min_value_exact);
             $xfer += $output->writeFieldEnd();
         }
+        if ($this->nan_count !== null) {
+            $xfer += $output->writeFieldBegin('nan_count', TType::I64, 9);
+            $xfer += $output->writeI64($this->nan_count);
+            $xfer += $output->writeFieldEnd();
+        }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/StringType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/StringType.php
index 95dffcb488..441d949af0 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/StringType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/StringType.php
@@ -1,34 +1,42 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Empty structs to use as logical type annotations.
+ * Empty structs to use as logical type annotations
  */
 class StringType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'StringType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -36,24 +44,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -63,7 +66,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('StringType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeType.php
index 24ef8e9c47..ffbf40536b 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeType.php
@@ -1,51 +1,52 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Time logical type annotation.
- *
+ * Time logical type annotation
+ * 
  * Allowed for physical types: INT32 (millis), INT64 (micros, nanos)
  */
 class TimeType
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'isAdjustedToUTC',
             'isRequired' => true,
             'type' => TType::BOOL,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'unit',
             'isRequired' => true,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\TimeUnit',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * @var bool
      */
-    public $isAdjustedToUTC;
-
+    public $isAdjustedToUTC = null;
     /**
-     * @var TimeUnit
+     * @var \Flow\Parquet\ThriftModel\TimeUnit
      */
-    public $unit;
+    public $unit = null;
 
     public function __construct($vals = null)
     {
@@ -53,7 +54,6 @@ public function __construct($vals = null)
             if (isset($vals['isAdjustedToUTC'])) {
                 $this->isAdjustedToUTC = $vals['isAdjustedToUTC'];
             }
-
             if (isset($vals['unit'])) {
                 $this->unit = $vals['unit'];
             }
@@ -65,6 +65,7 @@ public function getName()
         return 'TimeType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -72,14 +73,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::BOOL) {
@@ -87,27 +85,22 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->unit = new TimeUnit();
+                        $this->unit = new \Flow\Parquet\ThriftModel\TimeUnit();
                         $xfer += $this->unit->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -115,13 +108,11 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('TimeType');
-
         if ($this->isAdjustedToUTC !== null) {
             $xfer += $output->writeFieldBegin('isAdjustedToUTC', TType::BOOL, 1);
             $xfer += $output->writeBool($this->isAdjustedToUTC);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->unit !== null) {
             if (!is_object($this->unit)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -132,7 +123,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeUnit.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeUnit.php
index 8367bda037..a7869e4258 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeUnit.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimeUnit.php
@@ -1,58 +1,58 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class TimeUnit
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'MILLIS',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\MilliSeconds',
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'MICROS',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\MicroSeconds',
-        ],
-        3 => [
+        ),
+        3 => array(
             'var' => 'NANOS',
             'isRequired' => false,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\NanoSeconds',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
-     * @var MicroSeconds
+     * @var null|\Flow\Parquet\ThriftModel\MilliSeconds
      */
-    public $MICROS;
-
+    public $MILLIS = null;
     /**
-     * @var MilliSeconds
+     * @var null|\Flow\Parquet\ThriftModel\MicroSeconds
      */
-    public $MILLIS;
-
+    public $MICROS = null;
     /**
-     * @var NanoSeconds
+     * @var null|\Flow\Parquet\ThriftModel\NanoSeconds
      */
-    public $NANOS;
+    public $NANOS = null;
 
     public function __construct($vals = null)
     {
@@ -60,11 +60,9 @@ public function __construct($vals = null)
             if (isset($vals['MILLIS'])) {
                 $this->MILLIS = $vals['MILLIS'];
             }
-
             if (isset($vals['MICROS'])) {
                 $this->MICROS = $vals['MICROS'];
             }
-
             if (isset($vals['NANOS'])) {
                 $this->NANOS = $vals['NANOS'];
             }
@@ -76,6 +74,7 @@ public function getName()
         return 'TimeUnit';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -83,52 +82,43 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::STRUCT) {
-                        $this->MILLIS = new MilliSeconds();
+                        $this->MILLIS = new \Flow\Parquet\ThriftModel\MilliSeconds();
                         $xfer += $this->MILLIS->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->MICROS = new MicroSeconds();
+                        $this->MICROS = new \Flow\Parquet\ThriftModel\MicroSeconds();
                         $xfer += $this->MICROS->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 3:
                     if ($ftype == TType::STRUCT) {
-                        $this->NANOS = new NanoSeconds();
+                        $this->NANOS = new \Flow\Parquet\ThriftModel\NanoSeconds();
                         $xfer += $this->NANOS->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -136,7 +126,6 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('TimeUnit');
-
         if ($this->MILLIS !== null) {
             if (!is_object($this->MILLIS)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -145,7 +134,6 @@ public function write($output)
             $xfer += $this->MILLIS->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->MICROS !== null) {
             if (!is_object($this->MICROS)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -154,7 +142,6 @@ public function write($output)
             $xfer += $this->MICROS->write($output);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->NANOS !== null) {
             if (!is_object($this->NANOS)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -165,7 +152,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimestampType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimestampType.php
index 2ad64ee927..19240e1f6e 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimestampType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TimestampType.php
@@ -1,51 +1,52 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
-use Thrift\Exception\TProtocolException;
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Timestamp logical type annotation.
- *
- * Allowed for physical types: INT64
+ * Timestamp logical type annotation
+ * 
+ * Allowed for physical types: INT64 and FIXED_LEN_BYTE_ARRAY with `type_length` = 12.
  */
 class TimestampType
 {
-    public static $_TSPEC = [
-        1 => [
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
             'var' => 'isAdjustedToUTC',
             'isRequired' => true,
             'type' => TType::BOOL,
-        ],
-        2 => [
+        ),
+        2 => array(
             'var' => 'unit',
             'isRequired' => true,
             'type' => TType::STRUCT,
             'class' => '\Flow\Parquet\ThriftModel\TimeUnit',
-        ],
-    ];
-
-    public static $isValidate = false;
+        ),
+    );
 
     /**
      * @var bool
      */
-    public $isAdjustedToUTC;
-
+    public $isAdjustedToUTC = null;
     /**
-     * @var TimeUnit
+     * @var \Flow\Parquet\ThriftModel\TimeUnit
      */
-    public $unit;
+    public $unit = null;
 
     public function __construct($vals = null)
     {
@@ -53,7 +54,6 @@ public function __construct($vals = null)
             if (isset($vals['isAdjustedToUTC'])) {
                 $this->isAdjustedToUTC = $vals['isAdjustedToUTC'];
             }
-
             if (isset($vals['unit'])) {
                 $this->unit = $vals['unit'];
             }
@@ -65,6 +65,7 @@ public function getName()
         return 'TimestampType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -72,14 +73,11 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 case 1:
                     if ($ftype == TType::BOOL) {
@@ -87,27 +85,22 @@ public function read($input)
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
                 case 2:
                     if ($ftype == TType::STRUCT) {
-                        $this->unit = new TimeUnit();
+                        $this->unit = new \Flow\Parquet\ThriftModel\TimeUnit();
                         $xfer += $this->unit->read($input);
                     } else {
                         $xfer += $input->skip($ftype);
                     }
-
                     break;
-
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -115,13 +108,11 @@ public function write($output)
     {
         $xfer = 0;
         $xfer += $output->writeStructBegin('TimestampType');
-
         if ($this->isAdjustedToUTC !== null) {
             $xfer += $output->writeFieldBegin('isAdjustedToUTC', TType::BOOL, 1);
             $xfer += $output->writeBool($this->isAdjustedToUTC);
             $xfer += $output->writeFieldEnd();
         }
-
         if ($this->unit !== null) {
             if (!is_object($this->unit)) {
                 throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -132,7 +123,6 @@ public function write($output)
         }
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Type.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Type.php
index 32f9848642..d9704064a5 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Type.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Type.php
@@ -1,16 +1,21 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
 /**
  * Types supported by Parquet.  These types are intended to be used in combination
  * with the encodings to control the on disk storage format.
@@ -19,23 +24,23 @@
  */
 final class Type
 {
-    public const BOOLEAN = 0;
+    const BOOLEAN = 0;
 
-    public const BYTE_ARRAY = 6;
+    const INT32 = 1;
 
-    public const DOUBLE = 5;
+    const INT64 = 2;
 
-    public const FIXED_LEN_BYTE_ARRAY = 7;
+    const INT96 = 3;
 
-    public const FLOAT = 4;
+    const FLOAT = 4;
 
-    public const INT32 = 1;
+    const DOUBLE = 5;
 
-    public const INT64 = 2;
+    const BYTE_ARRAY = 6;
 
-    public const INT96 = 3;
+    const FIXED_LEN_BYTE_ARRAY = 7;
 
-    public static $__names = [
+    static public $__names = array(
         0 => 'BOOLEAN',
         1 => 'INT32',
         2 => 'INT64',
@@ -44,5 +49,6 @@ final class Type
         5 => 'DOUBLE',
         6 => 'BYTE_ARRAY',
         7 => 'FIXED_LEN_BYTE_ARRAY',
-    ];
+    );
 }
+
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TypeDefinedOrder.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TypeDefinedOrder.php
index 6709206bf8..f16b67404f 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/TypeDefinedOrder.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/TypeDefinedOrder.php
@@ -1,34 +1,42 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
- * Empty struct to signal the order defined by the physical or logical type.
+ * Empty struct to signal the order defined by the physical or logical type
  */
 class TypeDefinedOrder
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'TypeDefinedOrder';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -36,24 +44,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -63,7 +66,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('TypeDefinedOrder');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/UUIDType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/UUIDType.php
index b58db9934b..d485bebd74 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/UUIDType.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/UUIDType.php
@@ -1,31 +1,39 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 class UUIDType
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'UUIDType';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -33,24 +41,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -60,7 +63,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('UUIDType');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Uncompressed.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Uncompressed.php
index 0a74222ace..48a6280f85 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/Uncompressed.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/Uncompressed.php
@@ -1,34 +1,43 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * The compression used in the Bloom filter.
+ * 
  */
 class Uncompressed
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'Uncompressed';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -36,24 +45,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -63,7 +67,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('Uncompressed');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/VariantType.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/VariantType.php
new file mode 100644
index 0000000000..c9c4bf692f
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/VariantType.php
@@ -0,0 +1,97 @@
+<?php
+namespace Flow\Parquet\ThriftModel;
+
+/**
+ * Autogenerated by Thrift Compiler (0.22.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+/**
+ * Embedded Variant logical type annotation
+ */
+class VariantType
+{
+    static public $isValidate = false;
+
+    static public $_TSPEC = array(
+        1 => array(
+            'var' => 'specification_version',
+            'isRequired' => false,
+            'type' => TType::BYTE,
+        ),
+    );
+
+    /**
+     * @var null|int
+     */
+    public $specification_version = null;
+
+    public function __construct($vals = null)
+    {
+        if (is_array($vals)) {
+            if (isset($vals['specification_version'])) {
+                $this->specification_version = $vals['specification_version'];
+            }
+        }
+    }
+
+    public function getName()
+    {
+        return 'VariantType';
+    }
+
+
+    public function read($input)
+    {
+        $xfer = 0;
+        $fname = null;
+        $ftype = 0;
+        $fid = 0;
+        $xfer += $input->readStructBegin($fname);
+        while (true) {
+            $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+            if ($ftype == TType::STOP) {
+                break;
+            }
+            switch ($fid) {
+                case 1:
+                    if ($ftype == TType::BYTE) {
+                        $xfer += $input->readByte($this->specification_version);
+                    } else {
+                        $xfer += $input->skip($ftype);
+                    }
+                    break;
+                default:
+                    $xfer += $input->skip($ftype);
+                    break;
+            }
+            $xfer += $input->readFieldEnd();
+        }
+        $xfer += $input->readStructEnd();
+        return $xfer;
+    }
+
+    public function write($output)
+    {
+        $xfer = 0;
+        $xfer += $output->writeStructBegin('VariantType');
+        if ($this->specification_version !== null) {
+            $xfer += $output->writeFieldBegin('specification_version', TType::BYTE, 1);
+            $xfer += $output->writeByte($this->specification_version);
+            $xfer += $output->writeFieldEnd();
+        }
+        $xfer += $output->writeFieldStop();
+        $xfer += $output->writeStructEnd();
+        return $xfer;
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/ThriftModel/XxHash.php b/src/lib/parquet/src/Flow/Parquet/ThriftModel/XxHash.php
index 9758237bcd..de0c1bb403 100644
--- a/src/lib/parquet/src/Flow/Parquet/ThriftModel/XxHash.php
+++ b/src/lib/parquet/src/Flow/Parquet/ThriftModel/XxHash.php
@@ -1,35 +1,44 @@
 <?php
-
-declare(strict_types=1);
-
 namespace Flow\Parquet\ThriftModel;
 
 /**
- * Autogenerated by Thrift Compiler (0.18.1).
+ * Autogenerated by Thrift Compiler (0.22.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *
  *  @generated
  */
+use Thrift\Base\TBase;
 use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
 
 /**
  * Hash strategy type annotation. xxHash is an extremely fast non-cryptographic hash
  * algorithm. It uses 64 bits version of xxHash.
+ * 
  */
 class XxHash
 {
-    public static $_TSPEC = [];
+    static public $isValidate = false;
 
-    public static $isValidate = false;
+    static public $_TSPEC = array(
+    );
 
-    public function __construct() {}
+
+    public function __construct()
+    {
+    }
 
     public function getName()
     {
         return 'XxHash';
     }
 
+
     public function read($input)
     {
         $xfer = 0;
@@ -37,24 +46,19 @@ public function read($input)
         $ftype = 0;
         $fid = 0;
         $xfer += $input->readStructBegin($fname);
-
         while (true) {
             $xfer += $input->readFieldBegin($fname, $ftype, $fid);
-
             if ($ftype == TType::STOP) {
                 break;
             }
-
             switch ($fid) {
                 default:
                     $xfer += $input->skip($ftype);
-
                     break;
             }
             $xfer += $input->readFieldEnd();
         }
         $xfer += $input->readStructEnd();
-
         return $xfer;
     }
 
@@ -64,7 +68,6 @@ public function write($output)
         $xfer += $output->writeStructBegin('XxHash');
         $xfer += $output->writeFieldStop();
         $xfer += $output->writeStructEnd();
-
         return $xfer;
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilder.php
index 5191b04f15..2fb7ff7cce 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilder.php
@@ -29,7 +29,9 @@
 use Flow\Parquet\Writer\PageBuilder\RLEBitPackedPacker;
 use Flow\Parquet\Writer\PageContainer;
 use Flow\Parquet\Writer\PageContainers;
+use Flow\Parquet\Writer\PageIndexBuilder;
 use Flow\Parquet\Writer\StatisticsCounter;
+use Flow\Parquet\Writer\StatisticsOptions;
 use Flow\Parquet\Writer\ValueStorage\DeltaBinaryPackedValueStorage;
 use Flow\Parquet\Writer\ValueStorage\ValueStorage;
 
@@ -55,6 +57,8 @@ final class DeltaBinaryPackedColumnChunkBuilder implements ColumnChunkBuilder
 
     private StatisticsCounter $pageStatistics;
 
+    private PageIndexBuilder $pageIndex;
+
     /**
      * @var array<int>
      */
@@ -68,10 +72,12 @@ public function __construct(
         private readonly FlatColumn $column,
         private readonly Options $options,
         private readonly Compressions $compression,
+        private readonly StatisticsOptions $statistics,
     ) {
+        $this->pageIndex = $this->statistics->pageIndex($this->column);
         $this->pages = new PageContainers();
-        $this->chunkStatistics = new StatisticsCounter($this->column);
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->chunkStatistics = $this->statistics->counter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
         $this->valueStorage = new DeltaBinaryPackedValueStorage();
         $this->byteOrder = ByteOrder::LITTLE_ENDIAN;
 
@@ -128,6 +134,7 @@ public function closePage(): void
         };
 
         $this->pages->add($pageContainer);
+        $this->pageIndex->addPage($this->pageStatistics, $this->rowsCount);
         $this->chunkStatistics = $this->chunkStatistics->merge($this->pageStatistics);
 
         $this->repetitionLevels = [];
@@ -136,7 +143,7 @@ public function closePage(): void
         $this->rowsCount = 0;
         $this->nullCount = 0;
         $this->nonNullValuesCount = 0;
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
     }
 
     public function column(): Column
@@ -148,6 +155,7 @@ public function flush(int $fileOffset): array
     {
         $this->closePage();
 
+        $dataPageOffset = $fileOffset;
         $containers = [new ColumnChunkContainer(
             $this->pages->buffer(),
             new ColumnChunk(
@@ -160,15 +168,18 @@ public function flush(int $fileOffset): array
                 totalCompressedSize: $this->pages->compressedSize(),
                 totalUncompressedSize: $this->pages->uncompressedSize(),
                 dictionaryPageOffset: null,
-                dataPageOffset: $fileOffset,
+                dataPageOffset: $dataPageOffset,
                 indexPageOffset: null,
-                statistics: $this->chunkStatistics->toStatistics(),
+                statistics: $this->statistics->chunk($this->chunkStatistics),
             ),
+            $this->pageIndex->columnIndex(),
+            $this->pageIndex->offsetIndex($dataPageOffset, $this->pages),
         )];
 
         $this->pages = new PageContainers();
-        $this->chunkStatistics = new StatisticsCounter($this->column);
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->pageIndex = $this->statistics->pageIndex($this->column);
+        $this->chunkStatistics = $this->statistics->counter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
         $this->repetitionLevels = [];
         $this->definitionLevels = [];
         $this->valueStorage->reset();
@@ -237,6 +248,7 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
                 repetitionLevelEncoding: Encodings::RLE,
                 definitionLevelEncoding: Encodings::RLE,
                 valuesCount: count($this->definitionLevels),
+                statistics: $this->statistics->pageHeader($this->pageStatistics),
             ),
             dataPageHeaderV2: null,
             dictionaryPageHeader: null,
@@ -247,7 +259,7 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
 
     private function buildDataPageV2(Codec $codec, Compressions $compression): PageContainer
     {
-        $statistics = $this->pageStatistics->toStatistics();
+        $statistics = $this->statistics->pageHeader($this->pageStatistics);
 
         $rleBitPackedHybrid = new RLEBitPackedHybrid();
         $packer = new RLEBitPackedPacker($rleBitPackedHybrid, $this->byteOrder);
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilder.php
index 823ff84a8c..151fb5d4f0 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilder.php
@@ -27,7 +27,9 @@
 use Flow\Parquet\Writer\PageBuilder\RLEBitPackedPacker;
 use Flow\Parquet\Writer\PageContainer;
 use Flow\Parquet\Writer\PageContainers;
+use Flow\Parquet\Writer\PageIndexBuilder;
 use Flow\Parquet\Writer\StatisticsCounter;
+use Flow\Parquet\Writer\StatisticsOptions;
 use Flow\Parquet\Writer\ValueStorage\BooleanValueStorage;
 use Flow\Parquet\Writer\ValueStorage\BufferValueStorage;
 use Flow\Parquet\Writer\ValueStorage\ValueStorage;
@@ -55,6 +57,8 @@ final class PlainFlatColumnChunkBuilder implements ColumnChunkBuilder
 
     private StatisticsCounter $pageStatistics;
 
+    private PageIndexBuilder $pageIndex;
+
     /**
      * @var array<int>
      */
@@ -68,10 +72,12 @@ public function __construct(
         private readonly FlatColumn $column,
         private readonly Options $options,
         private readonly Compressions $compression,
+        private readonly StatisticsOptions $statistics,
     ) {
+        $this->pageIndex = $this->statistics->pageIndex($this->column);
         $this->pages = new PageContainers();
-        $this->chunkStatistics = new StatisticsCounter($this->column);
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->chunkStatistics = $this->statistics->counter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
         $this->byteOrder = ByteOrder::LITTLE_ENDIAN;
 
         $this->valueStorage = $this->column->type() === PhysicalType::BOOLEAN
@@ -127,6 +133,7 @@ public function closePage(): void
         };
 
         $this->pages->add($pageContainer);
+        $this->pageIndex->addPage($this->pageStatistics, $this->rowsCount);
         $this->chunkStatistics = $this->chunkStatistics->merge($this->pageStatistics);
 
         $this->repetitionLevels = [];
@@ -135,7 +142,7 @@ public function closePage(): void
         $this->rowsCount = 0;
         $this->nullCount = 0;
         $this->nonNullValuesCount = 0;
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
     }
 
     public function column(): Column
@@ -149,6 +156,9 @@ public function flush(int $fileOffset): array
 
         $dictionaryPageContainer = $this->pages->dictionaryPageContainer();
 
+        $dataPageOffset = $dictionaryPageContainer !== null
+            ? $fileOffset + $dictionaryPageContainer->totalCompressedSize()
+            : $fileOffset;
         $containers = [new ColumnChunkContainer(
             $this->pages->buffer(),
             new ColumnChunk(
@@ -161,17 +171,18 @@ public function flush(int $fileOffset): array
                 totalCompressedSize: $this->pages->compressedSize(),
                 totalUncompressedSize: $this->pages->uncompressedSize(),
                 dictionaryPageOffset: $dictionaryPageContainer !== null ? $fileOffset : null,
-                dataPageOffset: $dictionaryPageContainer !== null
-                    ? $fileOffset + $dictionaryPageContainer->totalCompressedSize()
-                    : $fileOffset,
+                dataPageOffset: $dataPageOffset,
                 indexPageOffset: null,
-                statistics: $this->chunkStatistics->toStatistics(),
+                statistics: $this->statistics->chunk($this->chunkStatistics),
             ),
+            $this->pageIndex->columnIndex(),
+            $this->pageIndex->offsetIndex($dataPageOffset, $this->pages),
         )];
 
         $this->pages = new PageContainers();
-        $this->chunkStatistics = new StatisticsCounter($this->column);
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->pageIndex = $this->statistics->pageIndex($this->column);
+        $this->chunkStatistics = $this->statistics->counter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
         $this->repetitionLevels = [];
         $this->definitionLevels = [];
         $this->valueStorage->reset();
@@ -236,6 +247,7 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
                 repetitionLevelEncoding: Encodings::RLE,
                 definitionLevelEncoding: Encodings::RLE,
                 valuesCount: count($this->definitionLevels),
+                statistics: $this->statistics->pageHeader($this->pageStatistics),
             ),
             dataPageHeaderV2: null,
             dictionaryPageHeader: null,
@@ -246,7 +258,7 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
 
     private function buildDataPageV2(Codec $codec, Compressions $compression): PageContainer
     {
-        $statistics = $this->pageStatistics->toStatistics();
+        $statistics = $this->statistics->pageHeader($this->pageStatistics);
 
         $rleBitPackedHybrid = new RLEBitPackedHybrid();
         $packer = new RLEBitPackedPacker($rleBitPackedHybrid, $this->byteOrder);
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilder.php
index a520d65838..1d485bb0ef 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilder.php
@@ -31,8 +31,11 @@
 use Flow\Parquet\Writer\PageBuilder\RLEBitPackedPacker;
 use Flow\Parquet\Writer\PageContainer;
 use Flow\Parquet\Writer\PageContainers;
+use Flow\Parquet\Writer\PageIndexBuilder;
 use Flow\Parquet\Writer\StatisticsCounter;
+use Flow\Parquet\Writer\StatisticsOptions;
 
+use function array_slice;
 use function count;
 use function strlen;
 
@@ -47,7 +50,15 @@ final class RLEDictionaryChunkBuilder implements ColumnChunkBuilder
      */
     private array $definitionLevels = [];
 
-    private ?Dictionary $dictionary = null;
+    /**
+     * The chunk's dictionary: every page's indices point into it, its page is written first at flush.
+     */
+    private Dictionary $dictionary;
+
+    /**
+     * The dictionary's PLAIN encoded size, compared to Option::DICTIONARY_PAGE_SIZE.
+     */
+    private int $dictionaryBytes = 0;
 
     private int $nullCount = 0;
 
@@ -55,6 +66,8 @@ final class RLEDictionaryChunkBuilder implements ColumnChunkBuilder
 
     private StatisticsCounter $pageStatistics;
 
+    private PageIndexBuilder $pageIndex;
+
     /**
      * @var array<null|bool|float|int|object|string>
      */
@@ -67,15 +80,24 @@ final class RLEDictionaryChunkBuilder implements ColumnChunkBuilder
 
     private int $rowsCount = 0;
 
+    /**
+     * Set once a page would grow the dictionary past Option::DICTIONARY_PAGE_SIZE: that page and the rest of the chunk
+     * are PLAIN, as arrow-rs falls back.
+     */
+    private bool $plain = false;
+
     public function __construct(
         private readonly FlatColumn $column,
         private readonly Options $options,
         private readonly Compressions $compression,
+        private readonly StatisticsOptions $statistics,
     ) {
+        $this->pageIndex = $this->statistics->pageIndex($this->column);
         $this->pages = new PageContainers();
-        $this->chunkStatistics = new StatisticsCounter($this->column);
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->chunkStatistics = $this->statistics->counter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
         $this->byteOrder = ByteOrder::LITTLE_ENDIAN;
+        $this->dictionary = new Dictionary([], []);
     }
 
     public function addColumn(WriteFlatColumnValues $columnValues): void
@@ -113,26 +135,11 @@ public function closePage(): void
         }
 
         $codec = new Codec($this->options);
-
-        if (count($this->pageValues) > 0) {
-            $flatColumnValues = new WriteFlatColumnValues(
-                $this->column,
-                $this->repetitionLevels,
-                $this->definitionLevels,
-                $this->pageValues,
-            );
-
-            $this->dictionary = (new DictionaryBuilder())->build($this->column, $flatColumnValues);
-
-            if (!$this->pages->dictionaryPageContainer()) {
-                $dictionaryPageContainer = $this->buildDictionaryPage($codec, $this->compression);
-                $this->pages->add($dictionaryPageContainer);
-            }
-        }
+        $indices = $this->plain ? null : $this->dictionaryIndices();
 
         $pageContainer = match ($writerVersion = $this->options->getInt(Option::WRITER_VERSION)) {
-            1 => $this->buildDataPage($codec, $this->compression),
-            2 => $this->buildDataPageV2($codec, $this->compression),
+            1 => $this->buildDataPage($codec, $this->compression, $indices),
+            2 => $this->buildDataPageV2($codec, $this->compression, $indices),
             default => throw new RuntimeException(
                 'Flow Parquet Writer does not support given version of Parquet format, supported versions are [1,2], given: '
                 . $writerVersion,
@@ -140,6 +147,7 @@ public function closePage(): void
         };
 
         $this->pages->add($pageContainer);
+        $this->pageIndex->addPage($this->pageStatistics, $this->rowsCount);
         $this->chunkStatistics = $this->chunkStatistics->merge($this->pageStatistics);
 
         $this->repetitionLevels = [];
@@ -147,7 +155,7 @@ public function closePage(): void
         $this->pageValues = [];
         $this->rowsCount = 0;
         $this->nullCount = 0;
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
     }
 
     public function column(): Column
@@ -159,8 +167,15 @@ public function flush(int $fileOffset): array
     {
         $this->closePage();
 
+        if ($this->dictionary->dictionary !== []) {
+            $this->pages->add($this->buildDictionaryPage(new Codec($this->options), $this->compression));
+        }
+
         $dictionaryPageContainer = $this->pages->dictionaryPageContainer();
 
+        $dataPageOffset = $dictionaryPageContainer !== null
+            ? $fileOffset + $dictionaryPageContainer->totalCompressedSize()
+            : $fileOffset;
         $containers = [new ColumnChunkContainer(
             $this->pages->buffer(),
             new ColumnChunk(
@@ -173,21 +188,24 @@ public function flush(int $fileOffset): array
                 totalCompressedSize: $this->pages->compressedSize(),
                 totalUncompressedSize: $this->pages->uncompressedSize(),
                 dictionaryPageOffset: $dictionaryPageContainer !== null ? $fileOffset : null,
-                dataPageOffset: $dictionaryPageContainer !== null
-                    ? $fileOffset + $dictionaryPageContainer->totalCompressedSize()
-                    : $fileOffset,
+                dataPageOffset: $dataPageOffset,
                 indexPageOffset: null,
-                statistics: $this->chunkStatistics->toStatistics(),
+                statistics: $this->statistics->chunk($this->chunkStatistics),
             ),
+            $this->pageIndex->columnIndex(),
+            $this->pageIndex->offsetIndex($dataPageOffset, $this->pages),
         )];
 
         $this->pages = new PageContainers();
-        $this->chunkStatistics = new StatisticsCounter($this->column);
-        $this->pageStatistics = new StatisticsCounter($this->column);
+        $this->pageIndex = $this->statistics->pageIndex($this->column);
+        $this->chunkStatistics = $this->statistics->counter($this->column);
+        $this->pageStatistics = $this->statistics->counter($this->column);
         $this->definitionLevels = [];
         $this->repetitionLevels = [];
         $this->pageValues = [];
-        $this->dictionary = null;
+        $this->dictionary = new Dictionary([], []);
+        $this->dictionaryBytes = 0;
+        $this->plain = false;
         $this->rowsCount = 0;
         $this->nullCount = 0;
 
@@ -213,7 +231,10 @@ public function uncompressedSize(): int
         return $this->pages->uncompressedSize() + $this->currentPageUncompressedSize();
     }
 
-    private function buildDataPage(Codec $codec, Compressions $compression): PageContainer
+    /**
+     * @param null|array<int, int> $indices the page's dictionary indices, null for a PLAIN page
+     */
+    private function buildDataPage(Codec $codec, Compressions $compression, ?array $indices): PageContainer
     {
         $rleBitPackedHybrid = new RLEBitPackedHybrid();
         $packer = new RLEBitPackedPacker($rleBitPackedHybrid, $this->byteOrder);
@@ -235,10 +256,7 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
             ));
         }
 
-        if ($this->dictionary && count($this->dictionary->indices) > 0) {
-            $bitWidth = BitWidth::fromArray($this->dictionary->indices);
-            $pageWriter->append($packer->packWithBitWidth($bitWidth, $this->dictionary->indices));
-        }
+        $pageWriter->append($this->values($packer, $indices));
 
         $compressedBuffer = $codec->compress($pageBuffer, $compression);
 
@@ -247,10 +265,11 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
             strlen($compressedBuffer),
             strlen($pageBuffer),
             dataPageHeader: new DataPageHeader(
-                encoding: Encodings::RLE_DICTIONARY,
+                encoding: $indices === null ? Encodings::PLAIN : Encodings::RLE_DICTIONARY,
                 repetitionLevelEncoding: Encodings::RLE,
                 definitionLevelEncoding: Encodings::RLE,
                 valuesCount: count($this->definitionLevels),
+                statistics: $this->statistics->pageHeader($this->pageStatistics),
             ),
             dataPageHeaderV2: null,
             dictionaryPageHeader: null,
@@ -259,9 +278,12 @@ private function buildDataPage(Codec $codec, Compressions $compression): PageCon
         return new PageContainer($compressedBuffer, $pageHeader);
     }
 
-    private function buildDataPageV2(Codec $codec, Compressions $compression): PageContainer
+    /**
+     * @param null|array<int, int> $indices the page's dictionary indices, null for a PLAIN page
+     */
+    private function buildDataPageV2(Codec $codec, Compressions $compression, ?array $indices): PageContainer
     {
-        $statistics = $this->pageStatistics->toStatistics();
+        $statistics = $this->statistics->pageHeader($this->pageStatistics);
 
         $rleBitPackedHybrid = new RLEBitPackedHybrid();
         $packer = new RLEBitPackedPacker($rleBitPackedHybrid, $this->byteOrder);
@@ -288,25 +310,19 @@ private function buildDataPageV2(Codec $codec, Compressions $compression): PageC
             $definitionsLength = 0;
         }
 
-        $indicesBuffer = '';
-
-        if ($this->dictionary && count($this->dictionary->indices) > 0) {
-            $bitWidth = BitWidth::fromArray($this->dictionary->indices);
-            $indicesBuffer = $packer->packWithBitWidth($bitWidth, $this->dictionary->indices);
-        }
-
-        $compressedBuffer = $codec->compress($indicesBuffer, $compression);
+        $valuesBuffer = $this->values($packer, $indices);
+        $compressedBuffer = $codec->compress($valuesBuffer, $compression);
 
         $pageHeader = new PageHeader(
             Type::DATA_PAGE_V2,
             strlen($compressedBuffer) + $repetitionsLength + $definitionsLength,
-            strlen($indicesBuffer) + $repetitionsLength + $definitionsLength,
+            strlen($valuesBuffer) + $repetitionsLength + $definitionsLength,
             dataPageHeader: null,
             dataPageHeaderV2: new DataPageHeaderV2(
                 valuesCount: count($this->definitionLevels),
                 nullsCount: $this->nullCount,
                 rowsCount: $this->rowsCount,
-                encoding: Encodings::RLE_DICTIONARY,
+                encoding: $indices === null ? Encodings::PLAIN : Encodings::RLE_DICTIONARY,
                 definitionsByteLength: $definitionsLength,
                 repetitionsByteLength: $repetitionsLength,
                 isCompressed: !($compression === Compressions::UNCOMPRESSED),
@@ -321,11 +337,6 @@ private function buildDataPageV2(Codec $codec, Compressions $compression): PageC
     private function buildDictionaryPage(Codec $codec, Compressions $compression): PageContainer
     {
         $dictionary = $this->dictionary;
-
-        if ($dictionary === null) {
-            throw new RuntimeException('Cannot build dictionary page without dictionary');
-        }
-
         $pageBuffer = '';
         $pageWriter = new BinaryBufferWriter($pageBuffer);
         (new PlainValuesPacker($pageWriter, $this->byteOrder))->packValues($this->column, $dictionary->dictionary);
@@ -344,6 +355,60 @@ private function buildDictionaryPage(Codec $codec, Compressions $compression): P
         return new PageContainer($compressedBuffer, $pageHeader);
     }
 
+    /**
+     * The page's values in the chunk dictionary, extending it; null when that would grow it past
+     * Option::DICTIONARY_PAGE_SIZE, which turns this page and the rest of the chunk PLAIN.
+     *
+     * @return null|array<int, int>
+     */
+    private function dictionaryIndices(): ?array
+    {
+        $extended = (new DictionaryBuilder())->build(
+            $this->column,
+            new WriteFlatColumnValues(
+                $this->column,
+                $this->repetitionLevels,
+                $this->definitionLevels,
+                $this->pageValues,
+            ),
+            $this->dictionary,
+        );
+        $added = '';
+        (new PlainValuesPacker(new BinaryBufferWriter($added), $this->byteOrder))->packValues(
+            $this->column,
+            array_slice($extended->dictionary, count($this->dictionary->dictionary)),
+        );
+
+        if (($this->dictionaryBytes + strlen($added)) > $this->options->getInt(Option::DICTIONARY_PAGE_SIZE)) {
+            $this->plain = true;
+
+            return null;
+        }
+
+        $this->dictionary = $extended;
+        $this->dictionaryBytes += strlen($added);
+
+        return $extended->indices;
+    }
+
+    /**
+     * @param null|array<int, int> $indices
+     */
+    private function values(RLEBitPackedPacker $packer, ?array $indices): string
+    {
+        if ($indices === null) {
+            $values = '';
+            (new PlainValuesPacker(new BinaryBufferWriter($values), $this->byteOrder))->packValues(
+                $this->column,
+                $this->pageValues,
+            );
+
+            return $values;
+        }
+
+        return $indices === [] ? '' : $packer->packWithBitWidth(BitWidth::fromArray($indices), $indices);
+    }
+
     private function currentPageUncompressedSize(): int
     {
         return (
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilderFactory.php b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilderFactory.php
index f25365bbd0..3044ae862e 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilderFactory.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilderFactory.php
@@ -23,6 +23,7 @@ public static function createBuilder(
         FlatColumn $column,
         Options $options,
         Compressions $compressions,
+        StatisticsOptions $statistics,
     ): ColumnChunkBuilder {
         $columnCompression = $compressions;
         $flatPath = $column->flatPath();
@@ -49,7 +50,7 @@ public static function createBuilder(
                 $encoding = $columnsEncodings[$flatPath];
 
                 if ($encoding instanceof Encodings) {
-                    return self::createForEncoding($column, $encoding, $options, $columnCompression);
+                    return self::createForEncoding($column, $encoding, $options, $columnCompression, $statistics);
                 }
             }
         }
@@ -58,10 +59,10 @@ public static function createBuilder(
             ($column->type() === PhysicalType::INT32 || $column->type() === PhysicalType::INT64)
             && $options->getInt(Option::WRITER_VERSION) === 2
         ) {
-            return new DeltaBinaryPackedColumnChunkBuilder($column, $options, $columnCompression);
+            return new DeltaBinaryPackedColumnChunkBuilder($column, $options, $columnCompression, $statistics);
         }
 
-        return new PlainFlatColumnChunkBuilder($column, $options, $columnCompression);
+        return new PlainFlatColumnChunkBuilder($column, $options, $columnCompression, $statistics);
     }
 
     private static function createForEncoding(
@@ -69,13 +70,19 @@ private static function createForEncoding(
         Encodings $encoding,
         Options $options,
         Compressions $compressions,
+        StatisticsOptions $statistics,
     ): ColumnChunkBuilder {
         self::validateEncodingForColumn($column, $encoding);
 
         return match ($encoding) {
-            Encodings::PLAIN => new PlainFlatColumnChunkBuilder($column, $options, $compressions),
-            Encodings::RLE_DICTIONARY => new RLEDictionaryChunkBuilder($column, $options, $compressions),
-            Encodings::DELTA_BINARY_PACKED => new DeltaBinaryPackedColumnChunkBuilder($column, $options, $compressions),
+            Encodings::PLAIN => new PlainFlatColumnChunkBuilder($column, $options, $compressions, $statistics),
+            Encodings::RLE_DICTIONARY => new RLEDictionaryChunkBuilder($column, $options, $compressions, $statistics),
+            Encodings::DELTA_BINARY_PACKED => new DeltaBinaryPackedColumnChunkBuilder(
+                $column,
+                $options,
+                $compressions,
+                $statistics,
+            ),
             default => throw new InvalidArgumentException("Unsupported encoding for column builder: {$encoding->name}"),
         };
     }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilders.php b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilders.php
index 62fba8475b..53d964727c 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilders.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkBuilders.php
@@ -4,6 +4,10 @@
 
 namespace Flow\Parquet\Writer;
 
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\BloomFilter\SbbfBuilder;
 use Flow\Parquet\Dremel\ColumnData\WriteFlatColumnValues;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
@@ -12,10 +16,26 @@
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
 use Flow\Parquet\Writer\ColumnChunkBuilder\NestedColumnChunkBuilder;
 
+use function array_key_exists;
+use function str_repeat;
 use function strlen;
 
 final class ColumnChunkBuilders
 {
+    /**
+     * The columns that get a bloom filter, by flat path.
+     *
+     * @var array<string, array{FlatColumn, BloomFilterOptions}>
+     */
+    private array $bloomFilterColumns = [];
+
+    /**
+     * The current row group's filters, created on a column's first non-null value.
+     *
+     * @var array<string, SbbfBuilder>
+     */
+    private array $bloomFilters = [];
+
     /**
      * @var array<string, ColumnChunkBuilder>
      */
@@ -26,19 +46,26 @@ final class ColumnChunkBuilders
      */
     public function __construct(
         private readonly array $builders,
+        private readonly BloomHash $bloomHash = new BloomHash(),
     ) {}
 
     public static function initialize(Schema $schema, Options $options, Compressions $compressions): self
     {
         $builders = [];
         $flatBuilders = [];
+        $statistics = StatisticsOptions::fromOptions($options);
 
         foreach ($schema->columns() as $column) {
             if ($column instanceof NestedColumn) {
                 $childBuilders = [];
 
                 foreach ($column->childrenFlat() as $flatChild) {
-                    $builder = ColumnChunkBuilderFactory::createBuilder($flatChild, $options, $compressions);
+                    $builder = ColumnChunkBuilderFactory::createBuilder(
+                        $flatChild,
+                        $options,
+                        $compressions,
+                        $statistics,
+                    );
                     $childBuilders[$flatChild->flatPath()] = $builder;
                     $flatBuilders[$flatChild->flatPath()] = $builder;
                 }
@@ -46,7 +73,7 @@ public static function initialize(Schema $schema, Options $options, Compressions
                 $builders[$column->name()] = new NestedColumnChunkBuilder($column, $childBuilders);
             } else {
                 /** @var FlatColumn $column */
-                $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+                $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions, $statistics);
                 $builders[$column->name()] = $builder;
                 $flatBuilders[$column->flatPath()] = $builder;
             }
@@ -54,6 +81,15 @@ public static function initialize(Schema $schema, Options $options, Compressions
 
         $instance = new self($builders);
         $instance->flatBuilders = $flatBuilders;
+        $bloomFilters = BloomFilterOptions::forColumns($options);
+
+        foreach ($schema->columnsFlat() as $flatColumn) {
+            $flatPath = $flatColumn->flatPath();
+
+            if (array_key_exists($flatPath, $bloomFilters)) {
+                $instance->bloomFilterColumns[$flatPath] = [$flatColumn, $bloomFilters[$flatPath]];
+            }
+        }
 
         return $instance;
     }
@@ -61,6 +97,21 @@ public static function initialize(Schema $schema, Options $options, Compressions
     public function addColumnByFlatPath(string $flatPath, WriteFlatColumnValues $columnValues): void
     {
         $this->flatBuilders[$flatPath]->addColumn($columnValues);
+
+        if (!array_key_exists($flatPath, $this->bloomFilterColumns)) {
+            return;
+        }
+
+        [$column, $options] = $this->bloomFilterColumns[$flatPath];
+
+        foreach ($columnValues->values() as $value) {
+            if ($value !== null) {
+                ($this->bloomFilters[$flatPath] ??= SbbfBuilder::for($options))->insert($this->bloomHash->of(
+                    $column,
+                    $value,
+                ));
+            }
+        }
     }
 
     /**
@@ -82,6 +133,8 @@ public function closePages(): void
     }
 
     /**
+     * Each container carries its chunk's bloom filter when the column has one.
+     *
      * @return array<ColumnChunkContainer>
      */
     public function flush(int $fileOffset): array
@@ -91,11 +144,25 @@ public function flush(int $fileOffset): array
 
         foreach ($this->builders as $builder) {
             foreach ($builder->flush($offset) as $container) {
-                $containers[] = $container;
+                $flatPath = $container->columnChunk->flatPath();
+                $containers[] = array_key_exists($flatPath, $this->bloomFilterColumns)
+                    ? new ColumnChunkContainer(
+                        $container->binaryBuffer,
+                        $container->columnChunk,
+                        $container->columnIndex,
+                        $container->offsetIndex,
+                        ($this->bloomFilters[$flatPath] ?? null)?->build() ?? Sbbf::fromBytes(str_repeat(
+                            "\0",
+                            Sbbf::BLOCK_BYTES,
+                        )),
+                    )
+                    : $container;
                 $offset += strlen($container->binaryBuffer);
             }
         }
 
+        $this->bloomFilters = [];
+
         return $containers;
     }
 
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkContainer.php b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkContainer.php
index 4dd914b4a8..209e180778 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkContainer.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/ColumnChunkContainer.php
@@ -4,6 +4,9 @@
 
 namespace Flow\Parquet\Writer;
 
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
 use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
 
 final readonly class ColumnChunkContainer
@@ -11,5 +14,8 @@
     public function __construct(
         public string $binaryBuffer,
         public ColumnChunk $columnChunk,
+        public ?ColumnIndex $columnIndex,
+        public OffsetIndex $offsetIndex,
+        public ?Sbbf $bloomFilter = null,
     ) {}
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/Dictionary.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/Dictionary.php
index 549b8d4fbf..852a7580d0 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/Dictionary.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/Dictionary.php
@@ -8,10 +8,12 @@
 {
     /**
      * @param array<int, mixed> $dictionary
-     * @param array<int, int> $indices
+     * @param array<int, int> $indices the indices of the values the dictionary was last extended with
+     * @param array<int|string, int> $keys each entry's lookup key to its index
      */
     public function __construct(
         public array $dictionary,
         public array $indices,
+        public array $keys = [],
     ) {}
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder.php
index a73e15f56b..ca2fa2d88d 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder.php
@@ -15,27 +15,35 @@
 
 final class DictionaryBuilder
 {
-    public function build(FlatColumn $column, WriteFlatColumnValues $data): Dictionary
-    {
+    /**
+     * $dictionary extended with the values of $data, its indices those of $data's values.
+     */
+    public function build(
+        FlatColumn $column,
+        WriteFlatColumnValues $data,
+        Dictionary $dictionary = new Dictionary([], []),
+    ): Dictionary {
         return match ($column->type()) {
             PhysicalType::INT64, PhysicalType::INT32 => match ($column->logicalType()?->name()) {
                 LogicalType::DATE, LogicalType::TIME, LogicalType::TIMESTAMP => (new ObjectDictionaryBuilder())->build(
                     $data,
+                    $dictionary,
                 ),
-                default => (new ScalarDictionaryBuilder())->build($data),
+                default => (new ScalarDictionaryBuilder())->build($data, $dictionary),
             },
-            PhysicalType::BOOLEAN => (new ScalarDictionaryBuilder())->build($data),
-            PhysicalType::FLOAT, PhysicalType::DOUBLE => (new FloatDictionaryBuilder())->build($data),
+            PhysicalType::BOOLEAN => (new ScalarDictionaryBuilder())->build($data, $dictionary),
+            PhysicalType::FLOAT, PhysicalType::DOUBLE => (new FloatDictionaryBuilder())->build($data, $dictionary),
             PhysicalType::FIXED_LEN_BYTE_ARRAY, PhysicalType::BYTE_ARRAY => match ($column->logicalType()?->name()) {
                 LogicalType::STRING,
                 LogicalType::JSON,
                 LogicalType::BSON,
                 LogicalType::UUID,
                 LogicalType::ENUM,
-                    => (new ScalarDictionaryBuilder())->build($data),
-                LogicalType::DECIMAL => (new FloatDictionaryBuilder())->build($data),
+                LogicalType::DECIMAL,
+                    => (new ScalarDictionaryBuilder())->build($data, $dictionary),
                 LogicalType::DATE, LogicalType::TIME, LogicalType::TIMESTAMP => (new ObjectDictionaryBuilder())->build(
                     $data,
+                    $dictionary,
                 ),
                 default => throw new RuntimeException(
                     'Building dictionary for "' . ($column->logicalType()?->name() ?? 'null') . '" is not supported',
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/FloatDictionaryBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/FloatDictionaryBuilder.php
index 15cef7752b..fa91ea66e6 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/FloatDictionaryBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/FloatDictionaryBuilder.php
@@ -7,16 +7,17 @@
 use Flow\Parquet\Dremel\ColumnData\WriteFlatColumnValues;
 use Flow\Parquet\Writer\PageBuilder\Dictionary;
 
+use function count;
 use function pack;
 
 final class FloatDictionaryBuilder
 {
-    public function build(WriteFlatColumnValues $data): Dictionary
+    public function build(WriteFlatColumnValues $data, Dictionary $dictionary = new Dictionary([], [])): Dictionary
     {
-        $dictionary = [];
+        $entries = $dictionary->dictionary;
         $indices = [];
-        $valueToIndex = [];
-        $dictionarySize = 0;
+        $valueToIndex = $dictionary->keys;
+        $dictionarySize = count($entries);
 
         foreach ($data->values() as $value) {
             if ($value === null) {
@@ -26,7 +27,7 @@ public function build(WriteFlatColumnValues $data): Dictionary
             $hash = pack('E', $value);
 
             if (!isset($valueToIndex[$hash])) {
-                $dictionary[] = $value;
+                $entries[] = $value;
                 $valueToIndex[$hash] = $dictionarySize;
                 $dictionarySize++;
             }
@@ -34,6 +35,6 @@ public function build(WriteFlatColumnValues $data): Dictionary
             $indices[] = $valueToIndex[$hash];
         }
 
-        return new Dictionary($dictionary, $indices);
+        return new Dictionary($entries, $indices, $valueToIndex);
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ObjectDictionaryBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ObjectDictionaryBuilder.php
index 5fe061bbea..2b1ec67a86 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ObjectDictionaryBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ObjectDictionaryBuilder.php
@@ -8,16 +8,17 @@
 use Flow\Parquet\Dremel\ColumnData\WriteFlatColumnValues;
 use Flow\Parquet\Writer\PageBuilder\Dictionary;
 
+use function count;
 use function serialize;
 
 final class ObjectDictionaryBuilder
 {
-    public function build(WriteFlatColumnValues $data): Dictionary
+    public function build(WriteFlatColumnValues $data, Dictionary $dictionary = new Dictionary([], [])): Dictionary
     {
-        $dictionary = [];
+        $entries = $dictionary->dictionary;
         $indices = [];
-        $valueToIndex = [];
-        $dictionarySize = 0;
+        $valueToIndex = $dictionary->keys;
+        $dictionarySize = count($entries);
 
         foreach ($data->values() as $value) {
             if ($value === null) {
@@ -31,7 +32,7 @@ public function build(WriteFlatColumnValues $data): Dictionary
             }
 
             if (!isset($valueToIndex[$hash])) {
-                $dictionary[] = $value;
+                $entries[] = $value;
                 $valueToIndex[$hash] = $dictionarySize;
                 $dictionarySize++;
             }
@@ -39,6 +40,6 @@ public function build(WriteFlatColumnValues $data): Dictionary
             $indices[] = $valueToIndex[$hash];
         }
 
-        return new Dictionary($dictionary, $indices);
+        return new Dictionary($entries, $indices, $valueToIndex);
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ScalarDictionaryBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ScalarDictionaryBuilder.php
index 808cf214e7..816e0ff939 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ScalarDictionaryBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/PageBuilder/DictionaryBuilder/ScalarDictionaryBuilder.php
@@ -7,6 +7,7 @@
 use Flow\Parquet\Dremel\ColumnData\WriteFlatColumnValues;
 use Flow\Parquet\Writer\PageBuilder\Dictionary;
 
+use function count;
 use function is_bool;
 use function is_float;
 use function is_int;
@@ -16,12 +17,12 @@
 
 final class ScalarDictionaryBuilder
 {
-    public function build(WriteFlatColumnValues $data): Dictionary
+    public function build(WriteFlatColumnValues $data, Dictionary $dictionary = new Dictionary([], [])): Dictionary
     {
-        $dictionary = [];
+        $entries = $dictionary->dictionary;
         $indices = [];
-        $valueToIndex = [];
-        $dictionarySize = 0;
+        $valueToIndex = $dictionary->keys;
+        $dictionarySize = count($entries);
 
         foreach ($data->values() as $value) {
             if ($value === null) {
@@ -39,7 +40,7 @@ public function build(WriteFlatColumnValues $data): Dictionary
             }
 
             if (!isset($valueToIndex[$key])) {
-                $dictionary[] = $value;
+                $entries[] = $value;
                 $valueToIndex[$key] = $dictionarySize;
                 $dictionarySize++;
             }
@@ -47,6 +48,6 @@ public function build(WriteFlatColumnValues $data): Dictionary
             $indices[] = $valueToIndex[$key];
         }
 
-        return new Dictionary($dictionary, $indices);
+        return new Dictionary($entries, $indices, $valueToIndex);
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/PageIndexBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/PageIndexBuilder.php
new file mode 100644
index 0000000000..bf78902757
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/PageIndexBuilder.php
@@ -0,0 +1,158 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Writer;
+
+use Flow\Parquet\Data\PhysicalCodec;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+/**
+ * One column chunk's page index, page by page, as arrow-rs builds it: a column index only at StatisticsLevel::PAGE and
+ * only while every page that holds a value has bounds, an offset index always.
+ */
+final class PageIndexBuilder
+{
+    private bool $ascending = true;
+
+    private readonly PhysicalCodec $codec;
+
+    private bool $descending = true;
+
+    private bool|float|int|string|null $lastMax = null;
+
+    private bool|float|int|string|null $lastMin = null;
+
+    /**
+     * @var list<string>
+     */
+    private array $maxValues = [];
+
+    /**
+     * @var list<string>
+     */
+    private array $minValues = [];
+
+    /**
+     * @var list<int>
+     */
+    private array $nanCounts = [];
+
+    /**
+     * @var list<int>
+     */
+    private array $nullCounts = [];
+
+    /**
+     * @var list<bool>
+     */
+    private array $nullPages = [];
+
+    private readonly PhysicalOrder $order;
+
+    /**
+     * @var list<int>
+     */
+    private array $pageRows = [];
+
+    private bool $valid;
+
+    public function __construct(
+        private readonly FlatColumn $column,
+        StatisticsLevel $level,
+        private readonly StatisticsTruncation $truncation,
+    ) {
+        $this->codec = new PhysicalCodec();
+        $this->order = PhysicalOrder::forColumn($column);
+        $this->valid = $level === StatisticsLevel::PAGE;
+    }
+
+    public function addPage(StatisticsCounter $statistics, int $rows): void
+    {
+        $this->pageRows[] = $rows;
+
+        if (!$this->valid) {
+            return;
+        }
+
+        $this->nullCounts[] = $statistics->nullCount();
+        $this->nanCounts[] = (int) $statistics->nanCount();
+
+        if ($statistics->notNullCount() === 0) {
+            $this->nullPages[] = true;
+            $this->minValues[] = '';
+            $this->maxValues[] = '';
+
+            return;
+        }
+
+        $min = $statistics->min();
+        $max = $statistics->max();
+
+        if ($min === null || $max === null) {
+            $this->valid = false;
+
+            return;
+        }
+
+        if ($this->lastMin !== null && $this->lastMax !== null) {
+            $this->ascending =
+                $this->ascending
+                && $this->order->compare($this->lastMin, $min) <= 0
+                && $this->order->compare($this->lastMax, $max) <= 0;
+            $this->descending =
+                $this->descending
+                && $this->order->compare($min, $this->lastMin) <= 0
+                && $this->order->compare($max, $this->lastMax) <= 0;
+        }
+
+        $this->lastMin = $min;
+        $this->lastMax = $max;
+        $this->nullPages[] = false;
+        $this->minValues[] = $this->truncation->min($this->column, $this->codec->encodeStatistic($this->column, $min));
+        $this->maxValues[] = $this->truncation->max($this->column, $this->codec->encodeStatistic($this->column, $max));
+    }
+
+    public function columnIndex(): ?ColumnIndex
+    {
+        if (!$this->valid || $this->nullPages === []) {
+            return null;
+        }
+
+        return new ColumnIndex(
+            $this->nullPages,
+            $this->minValues,
+            $this->maxValues,
+            match (true) {
+                $this->ascending => BoundaryOrder::ASCENDING,
+                $this->descending => BoundaryOrder::DESCENDING,
+                default => BoundaryOrder::UNORDERED,
+            },
+            $this->nullCounts,
+            $this->order->isFloatingPoint() ? $this->nanCounts : null,
+        );
+    }
+
+    /**
+     * The data pages written from $firstDataPageOffset on, header included, one per addPage() call.
+     */
+    public function offsetIndex(int $firstDataPageOffset, PageContainers $pages): OffsetIndex
+    {
+        $locations = [];
+        $offset = $firstDataPageOffset;
+        $firstRow = 0;
+
+        foreach ($pages->dataPageContainers() as $page => $container) {
+            $locations[] = new PageLocation($offset, $container->totalCompressedSize(), $firstRow);
+            $offset += $container->totalCompressedSize();
+            $firstRow += $this->pageRows[$page];
+        }
+
+        return new OffsetIndex($locations);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/RowGroupBuilder.php b/src/lib/parquet/src/Flow/Parquet/Writer/RowGroupBuilder.php
index 0520224f59..57ee93909f 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/RowGroupBuilder.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/RowGroupBuilder.php
@@ -6,6 +6,7 @@
 
 use Flow\Parquet\Dremel\DremelShredder;
 use Flow\Parquet\Dremel\RowGroupContainer;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
@@ -16,6 +17,7 @@
 use function array_slice;
 use function count;
 use function min;
+use function strlen;
 
 final class RowGroupBuilder
 {
@@ -28,17 +30,42 @@ final class RowGroupBuilder
 
     private int $rowsCount = 0;
 
+    /**
+     * Rows in the pages not closed yet: every column closes its page at the same row.
+     */
+    private int $pageRows = 0;
+
     /**
      * Rows of the row groups flushed before this one: the writer's index of this group's first row.
      */
     private int $flushedRows = 0;
 
+    private readonly int $pageMaximumRows;
+
+    private readonly int $rowGroupSizeBytes;
+
     public function __construct(
         private readonly Schema $schema,
         private readonly Compressions $compression,
         private readonly Options $options,
         private readonly DremelShredder $shredder,
     ) {
+        $this->pageMaximumRows = $this->options->getInt(Option::PAGE_MAXIMUM_ROWS_COUNT);
+
+        if ($this->pageMaximumRows < 1) {
+            throw new InvalidArgumentException(
+                Option::PAGE_MAXIMUM_ROWS_COUNT->name . ' must be greater than 0, ' . $this->pageMaximumRows . ' given',
+            );
+        }
+
+        $this->rowGroupSizeBytes = $this->options->getInt(Option::ROW_GROUP_SIZE_BYTES);
+
+        if ($this->rowGroupSizeBytes < 1) {
+            throw new InvalidArgumentException(
+                Option::ROW_GROUP_SIZE_BYTES->name . ' must be greater than 0, ' . $this->rowGroupSizeBytes . ' given',
+            );
+        }
+
         $this->columnChunkBuilders = ColumnChunkBuilders::initialize($this->schema, $this->options, $this->compression);
     }
 
@@ -76,10 +103,7 @@ public function addRows(array $rows): void
             }
 
             $this->rowsCount += count($chunk);
-
-            if ($this->columnChunkBuilders->isAnyPageFull()) {
-                $this->columnChunkBuilders->closePages();
-            }
+            $this->closeFullPages(count($chunk));
         }
     }
 
@@ -114,13 +138,13 @@ public function addColumns(array $columns, int $count): void
             }
 
             $this->rowsCount += $length;
-
-            if ($this->columnChunkBuilders->isAnyPageFull()) {
-                $this->columnChunkBuilders->closePages();
-            }
+            $this->closeFullPages($length);
         }
     }
 
+    /**
+     * The row group's column chunks, then their bloom filters (arrow-rs BloomFilterPosition::AfterRowGroup).
+     */
     public function flush(int $fileOffset): RowGroupContainer
     {
         $this->flushBuffer();
@@ -129,15 +153,36 @@ public function flush(int $fileOffset): RowGroupContainer
         $offset = $fileOffset;
         $buffer = '';
         $chunks = [];
+        $columnIndexes = [];
+        $offsetIndexes = [];
         $this->flushedRows += $rowsCount;
         $this->rowsCount = 0;
+        $this->pageRows = 0;
+
+        $bloomFilters = [];
 
         foreach ($this->columnChunkBuilders->flush($offset) as $container) {
             $chunks[] = $container->columnChunk;
+            $columnIndexes[] = $container->columnIndex;
+            $offsetIndexes[] = $container->offsetIndex;
+            $bloomFilters[] = $container->bloomFilter;
             $buffer .= $container->binaryBuffer;
         }
 
-        return new RowGroupContainer($buffer, new RowGroup($chunks, $rowsCount));
+        foreach ($bloomFilters as $index => $bloomFilter) {
+            if ($bloomFilter === null) {
+                continue;
+            }
+
+            $bytes = $bloomFilter->serialized();
+            $chunks[$index] = $chunks[$index]->withLocations(
+                bloomFilterOffset: $fileOffset + strlen($buffer),
+                bloomFilterLength: strlen($bytes),
+            );
+            $buffer .= $bytes;
+        }
+
+        return new RowGroupContainer($buffer, new RowGroup($chunks, $rowsCount), $columnIndexes, $offsetIndexes);
     }
 
     public function isEmpty(): bool
@@ -147,7 +192,7 @@ public function isEmpty(): bool
 
     public function isFull(): bool
     {
-        return $this->columnChunkBuilders->uncompressedSize() >= $this->options->getInt(Option::ROW_GROUP_SIZE_BYTES);
+        return $this->columnChunkBuilders->uncompressedSize() >= $this->rowGroupSizeBytes;
     }
 
     public function rowsCount(): int
@@ -171,10 +216,21 @@ private function flushBuffer(): void
             $this->columnChunkBuilders->addColumnByFlatPath($flatPath, $columnValues);
         }
 
-        if ($this->columnChunkBuilders->isAnyPageFull()) {
+        $this->closeFullPages(count($this->rowBuffer));
+        $this->rowBuffer = [];
+    }
+
+    /**
+     * Pages close once one reaches PAGE_SIZE_BYTES or they hold PAGE_MAXIMUM_ROWS_COUNT rows, checked every
+     * PAGE_SIZE_CHECK_INTERVAL rows.
+     */
+    private function closeFullPages(int $rows): void
+    {
+        $this->pageRows += $rows;
+
+        if ($this->columnChunkBuilders->isAnyPageFull() || $this->pageRows >= $this->pageMaximumRows) {
             $this->columnChunkBuilders->closePages();
+            $this->pageRows = 0;
         }
-
-        $this->rowBuffer = [];
     }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsCounter.php b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsCounter.php
index c4c25d19ae..eb3dbcee27 100644
--- a/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsCounter.php
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsCounter.php
@@ -4,87 +4,57 @@
 
 namespace Flow\Parquet\Writer;
 
-use Flow\Parquet\Binary\ByteOrder;
-use Flow\Parquet\BinaryWriter\BinaryBufferWriter;
-use Flow\Parquet\Data\PlainValuesPacker;
-use Flow\Parquet\Dremel\Statistics\Comparator;
+use Flow\Parquet\Data\PhysicalCodec;
+use Flow\Parquet\Data\PhysicalOrder;
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
-use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\ParquetFile\Statistics;
 
 use function count;
-use function Flow\Parquet\array_flatten;
-use function is_array;
-use function substr;
+use function fdiv;
+use function is_nan;
+use function is_object;
+use function strcmp;
 
 final class StatisticsCounter
 {
-    private readonly ByteOrder $byteOrder;
+    /**
+     * Both bounds are NaN until the first non-NaN value: arrow-rs get_min_max replaces min and max together.
+     */
+    private bool $boundsAreNan = false;
 
-    private readonly Comparator $comparator;
+    private readonly PhysicalCodec $codec;
 
-    private mixed $max;
+    private readonly bool $floatingPoint;
 
-    private mixed $min;
+    private bool $bounded = false;
 
-    private int $nullCount;
+    private bool|float|int|string $max = 0;
 
-    private int $valuesCount;
+    private int|string $maxKey = 0;
 
-    public function __construct(
-        private readonly FlatColumn $column,
-    ) {
-        $this->nullCount = 0;
-        $this->valuesCount = 0;
-        $this->min = null;
-        $this->max = null;
-        $this->comparator = new Comparator();
-        $this->byteOrder = ByteOrder::LITTLE_ENDIAN;
-    }
+    private bool|float|int|string $min = 0;
 
-    /**
-     * @param null|array<null|bool|float|int|object|string>|bool|float|int|object|string $value
-     */
-    public function add(string|int|float|array|bool|object|null $value): void
-    {
-        if (is_array($value)) {
-            $value = array_flatten($value);
-        }
+    private int|string $minKey = 0;
 
-        if (is_array($value)) {
-            $arrayValuesCount = count($value);
-            $this->valuesCount += $arrayValuesCount ?: 1;
-        } else {
-            $this->valuesCount++;
-        }
+    private ?int $nanCount = null;
 
-        if ($value === null) {
-            $this->nullCount++;
+    private int $nullCount = 0;
 
-            return;
-        }
+    private readonly PhysicalOrder $order;
 
-        if (is_array($value)) {
-            // @mago-ignore analysis:mixed-assignment
-            foreach ($value as $val) {
-                if ($this->comparator->isLessThan($val, $this->min)) {
-                    $this->min = $val;
-                }
+    private readonly bool $signed;
 
-                if ($this->comparator->isGreaterThan($val, $this->max)) {
-                    $this->max = $val;
-                }
-            }
-        } else {
-            if ($this->comparator->isLessThan($value, $this->min)) {
-                $this->min = $value;
-            }
+    private int $valuesCount = 0;
 
-            if ($this->comparator->isGreaterThan($value, $this->max)) {
-                $this->max = $value;
-            }
-        }
+    public function __construct(
+        private readonly FlatColumn $column,
+        private readonly StatisticsTruncation $truncation,
+    ) {
+        $this->order = PhysicalOrder::forColumn($column);
+        $this->codec = new PhysicalCodec();
+        $this->signed = $this->order->isSigned();
+        $this->floatingPoint = $this->order->isFloatingPoint();
     }
 
     /**
@@ -93,22 +63,32 @@ public function add(string|int|float|array|bool|object|null $value): void
     public function addBatch(array $values): void
     {
         $this->valuesCount += count($values);
+        $physical = [];
 
         foreach ($values as $value) {
             if ($value === null) {
                 $this->nullCount++;
-
-                continue;
-            }
-
-            if ($this->comparator->isLessThan($value, $this->min)) {
-                $this->min = $value;
+            } elseif (is_object($value)) {
+                throw new InvalidArgumentException(
+                    'Column "' . $this->column->flatPath() . '" statistics take physical values, got ' . $value::class,
+                );
+            } else {
+                $physical[] = $value;
             }
+        }
 
-            if ($this->comparator->isGreaterThan($value, $this->max)) {
-                $this->max = $value;
-            }
+        if ($physical === []) {
+            return;
         }
+
+        match ($this->order) {
+            PhysicalOrder::Signed, PhysicalOrder::Boolean => $this->addNative($physical),
+            PhysicalOrder::Bytes => $this->addBytes($physical),
+            PhysicalOrder::Double, PhysicalOrder::Float => $this->addFloats($physical),
+            PhysicalOrder::Float16 => $this->addFloat16($physical),
+            PhysicalOrder::Decimal, PhysicalOrder::Unsigned32, PhysicalOrder::Unsigned64 => $this->addByKey($physical),
+            PhysicalOrder::Unordered => null,
+        };
     }
 
     public function addNulls(int $count): void
@@ -121,9 +101,9 @@ public function addNulls(int $count): void
         $this->valuesCount += $count;
     }
 
-    public function max(): mixed
+    public function max(): bool|float|int|string|null
     {
-        return $this->max;
+        return $this->bounded ? $this->max : null;
     }
 
     public function merge(self $statistics): self
@@ -132,23 +112,32 @@ public function merge(self $statistics): self
             throw new InvalidArgumentException('Cannot merge statistics for different columns.');
         }
 
-        $newStatistics = new self($this->column);
+        $merged = new self($this->column, $this->truncation);
+
+        foreach ([$this, $statistics] as $part) {
+            if ($part->bounded) {
+                $merged->addBatch([$part->min, $part->max]);
+            }
+        }
+
+        $merged->nullCount = $this->nullCount + $statistics->nullCount;
+        $merged->valuesCount = $this->valuesCount + $statistics->valuesCount;
+        $merged->nanCount =
+            $this->nanCount === null && $statistics->nanCount === null
+                ? null
+                : (int) $this->nanCount + (int) $statistics->nanCount;
 
-        $newStatistics->nullCount = $this->nullCount + $statistics->nullCount;
-        $newStatistics->valuesCount = $this->valuesCount + $statistics->valuesCount;
-        $newStatistics->min = $this->comparator->isLessThan($this->min, $statistics->min)
-            ? $this->min
-            : $statistics->min;
-        $newStatistics->max = $this->comparator->isGreaterThan($this->max, $statistics->max)
-            ? $this->max
-            : $statistics->max;
+        return $merged;
+    }
 
-        return $newStatistics;
+    public function min(): bool|float|int|string|null
+    {
+        return $this->bounded ? $this->min : null;
     }
 
-    public function min(): mixed
+    public function nanCount(): ?int
     {
-        return $this->min;
+        return $this->nanCount;
     }
 
     public function notNullCount(): int
@@ -165,49 +154,55 @@ public function reset(): void
     {
         $this->nullCount = 0;
         $this->valuesCount = 0;
-        $this->min = null;
-        $this->max = null;
+        $this->nanCount = null;
+        $this->bounded = false;
+        $this->boundsAreNan = false;
     }
 
-    public function toStatistics(): Statistics
+    /**
+     * Data page statistics: a float page always carries a nan_count, 0 for an all-null page (arrow-rs get_nan_count).
+     */
+    public function toPageStatistics(): Statistics
     {
-        $minBuffer = '';
-        $maxBuffer = '';
-
-        // @mago-ignore analysis:mixed-assignment
-        $min = $this->min();
-        // @mago-ignore analysis:mixed-assignment
-        $max = $this->max();
+        return $this->statistics($this->floatingPoint ? (int) $this->nanCount : $this->nanCount);
+    }
 
-        if ($min !== null) {
-            (new PlainValuesPacker(new BinaryBufferWriter($minBuffer), $this->byteOrder))->packValues(
-                $this->column,
-                [$min],
-            );
-        }
+    public function toStatistics(): Statistics
+    {
+        return $this->statistics($this->nanCount);
+    }
 
-        if ($max !== null) {
-            (new PlainValuesPacker(new BinaryBufferWriter($maxBuffer), $this->byteOrder))->packValues(
-                $this->column,
-                [$max],
+    private function statistics(?int $nanCount): Statistics
+    {
+        if (!$this->bounded) {
+            return new Statistics(
+                max: null,
+                min: null,
+                nullCount: $this->nullCount,
+                distinctCount: null,
+                maxValue: null,
+                minValue: null,
+                isMaxValueExact: false,
+                isMinValueExact: false,
+                nanCount: $nanCount,
             );
         }
 
-        if ($this->column->type() === PhysicalType::BYTE_ARRAY) {
-            // Statistics hold the PLAIN encoding of the value without the BYTE_ARRAY length prefix.
-            $minBuffer = substr($minBuffer, 4);
-            $maxBuffer = substr($maxBuffer, 4);
-        }
+        $min = $this->codec->encodeStatistic($this->column, $this->min);
+        $max = $this->codec->encodeStatistic($this->column, $this->max);
+        $minValue = $this->truncation->min($this->column, $min);
+        $maxValue = $this->truncation->max($this->column, $max);
 
         return new Statistics(
-            max: $maxBuffer !== '' ? $maxBuffer : null,
-            min: $minBuffer !== '' ? $minBuffer : null,
-            nullCount: $this->nullCount(),
+            max: $this->signed ? $maxValue : null,
+            min: $this->signed ? $minValue : null,
+            nullCount: $this->nullCount,
             distinctCount: null,
-            maxValue: $maxBuffer !== '' ? $maxBuffer : null,
-            minValue: $minBuffer !== '' ? $minBuffer : null,
-            isMaxValueExact: null,
-            isMinValueExact: null,
+            maxValue: $maxValue,
+            minValue: $minValue,
+            isMaxValueExact: $maxValue === $max,
+            isMinValueExact: $minValue === $min,
+            nanCount: $nanCount,
         );
     }
 
@@ -215,4 +210,150 @@ public function valuesCount(): int
     {
         return $this->valuesCount;
     }
+
+    /**
+     * @param non-empty-list<bool|float|int|string> $values
+     */
+    private function addByKey(array $values): void
+    {
+        foreach ($values as $value) {
+            $this->bound($value, $this->order->key($value), false);
+        }
+    }
+
+    /**
+     * @param non-empty-list<bool|float|int|string> $values
+     */
+    private function addBytes(array $values): void
+    {
+        foreach ($values as $value) {
+            $value = (string) $value;
+
+            if (!$this->bounded) {
+                $this->min = $value;
+                $this->max = $value;
+                $this->bounded = true;
+            } elseif (strcmp($value, (string) $this->min) < 0) {
+                $this->min = $value;
+            } elseif (strcmp($value, (string) $this->max) > 0) {
+                $this->max = $value;
+            }
+        }
+    }
+
+    /**
+     * @param non-empty-list<bool|float|int|string> $values
+     */
+    private function addFloat16(array $values): void
+    {
+        $nanCount = (int) $this->nanCount;
+
+        foreach ($values as $value) {
+            $nan = $this->order->isNan($value);
+            $nanCount += $nan ? 1 : 0;
+            $this->bound($value, $this->order->key($value), $nan);
+        }
+
+        $this->nanCount = $nanCount;
+    }
+
+    /**
+     * Native float order is the IEEE 754 total order except for -0.0/+0.0 ties and NaN, handled on their own.
+     *
+     * @param non-empty-list<bool|float|int|string> $values
+     */
+    private function addFloats(array $values): void
+    {
+        $this->nanCount = (int) $this->nanCount;
+
+        foreach ($values as $value) {
+            $value = (float) $value;
+
+            if (is_nan($value)) {
+                $this->nanCount++;
+
+                if (!$this->bounded) {
+                    $this->min = $value;
+                    $this->max = $value;
+                    $this->bounded = true;
+                    $this->boundsAreNan = true;
+                } elseif ($this->boundsAreNan && $this->order->compare($value, $this->min) < 0) {
+                    $this->min = $value;
+                } elseif ($this->boundsAreNan && $this->order->compare($value, $this->max) > 0) {
+                    $this->max = $value;
+                }
+
+                continue;
+            }
+
+            if (!$this->bounded || $this->boundsAreNan) {
+                $this->min = $value;
+                $this->max = $value;
+                $this->bounded = true;
+                $this->boundsAreNan = false;
+
+                continue;
+            }
+
+            if (
+                $value < $this->min
+                || $value === 0.0 && $this->min === 0.0 && fdiv(1.0, $value) < fdiv(1.0, $this->min)
+            ) {
+                $this->min = $value;
+            } elseif (
+                $value > $this->max
+                || $value === 0.0 && $this->max === 0.0 && fdiv(1.0, $value) > fdiv(1.0, $this->max)
+            ) {
+                $this->max = $value;
+            }
+        }
+    }
+
+    /**
+     * @param non-empty-list<bool|float|int|string> $values
+     */
+    private function addNative(array $values): void
+    {
+        foreach ($values as $value) {
+            if (!$this->bounded) {
+                $this->min = $value;
+                $this->max = $value;
+                $this->bounded = true;
+            } elseif ($value < $this->min) {
+                $this->min = $value;
+            } elseif ($value > $this->max) {
+                $this->max = $value;
+            }
+        }
+    }
+
+    /**
+     * The key-ordered paths (addByKey, addFloat16) keep minKey/maxKey; a NaN bound gives way to the first non-NaN
+     * value and never replaces one (arrow-rs get_min_max).
+     */
+    private function bound(bool|float|int|string $value, int|string $key, bool $nan): void
+    {
+        if (!$this->bounded || $this->boundsAreNan && !$nan) {
+            $this->min = $value;
+            $this->minKey = $key;
+            $this->max = $value;
+            $this->maxKey = $key;
+            $this->bounded = true;
+            $this->boundsAreNan = $nan;
+
+            return;
+        }
+
+        if ($this->boundsAreNan !== $nan) {
+            return;
+        }
+
+        if ($this->order->compareKeys($key, $this->minKey) < 0) {
+            $this->min = $value;
+            $this->minKey = $key;
+        } elseif ($this->order->compareKeys($key, $this->maxKey) > 0) {
+            $this->max = $value;
+            $this->maxKey = $key;
+        }
+    }
 }
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsLevel.php b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsLevel.php
new file mode 100644
index 0000000000..18d034e576
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsLevel.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Writer;
+
+/**
+ * Which statistics a writer computes, as arrow-rs EnabledStatistics: none, column chunk statistics, or column chunk
+ * statistics plus a column index entry per page.
+ */
+enum StatisticsLevel
+{
+    case CHUNK;
+    case NONE;
+    case PAGE;
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsOptions.php b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsOptions.php
new file mode 100644
index 0000000000..989a4e10e7
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsOptions.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Writer;
+
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Statistics;
+
+/**
+ * The statistics a writer computes, read from Options once for every column chunk builder.
+ */
+final readonly class StatisticsOptions
+{
+    public function __construct(
+        private StatisticsLevel $level,
+        private bool $pageHeaderStatistics,
+        private StatisticsTruncation $truncation,
+        private StatisticsTruncation $columnIndexTruncation,
+    ) {}
+
+    public static function fromOptions(Options $options): self
+    {
+        $level = $options->getEnum(Option::STATISTICS_LEVEL, StatisticsLevel::class);
+
+        return new self(
+            $level,
+            $level === StatisticsLevel::PAGE && $options->getBool(Option::PAGE_HEADER_STATISTICS),
+            new StatisticsTruncation($options->getInt(Option::STATISTICS_TRUNCATE_LENGTH)),
+            new StatisticsTruncation(
+                $options->getInt(Option::COLUMN_INDEX_TRUNCATE_LENGTH),
+                Option::COLUMN_INDEX_TRUNCATE_LENGTH,
+            ),
+        );
+    }
+
+    /**
+     * The column chunk's statistics, none at StatisticsLevel::NONE.
+     */
+    public function chunk(StatisticsCounter $chunk): ?Statistics
+    {
+        return $this->level === StatisticsLevel::NONE ? null : $chunk->toStatistics();
+    }
+
+    public function counter(FlatColumn $column): StatisticsCounter
+    {
+        return new StatisticsCounter($column, $this->truncation);
+    }
+
+    /**
+     * A data page header's statistics, only at StatisticsLevel::PAGE with Option::PAGE_HEADER_STATISTICS.
+     */
+    public function pageHeader(StatisticsCounter $page): ?Statistics
+    {
+        return $this->pageHeaderStatistics ? $page->toPageStatistics() : null;
+    }
+
+    /**
+     * A new page index for one column chunk.
+     */
+    public function pageIndex(FlatColumn $column): PageIndexBuilder
+    {
+        return new PageIndexBuilder($column, $this->level, $this->columnIndexTruncation);
+    }
+}
diff --git a/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsTruncation.php b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsTruncation.php
new file mode 100644
index 0000000000..fd4e0f7719
--- /dev/null
+++ b/src/lib/parquet/src/Flow/Parquet/Writer/StatisticsTruncation.php
@@ -0,0 +1,175 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Writer;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+
+use function chr;
+use function max;
+use function ord;
+use function preg_match;
+use function strlen;
+use function substr;
+
+/**
+ * arrow-rs 60 column/writer/mod.rs truncate_min_value / truncate_max_value. A truncated bound is not exact; a bound
+ * that cannot be truncated (or whose increment fails) is returned as given.
+ */
+final readonly class StatisticsTruncation
+{
+    public function __construct(
+        private int $length,
+        Option $option = Option::STATISTICS_TRUNCATE_LENGTH,
+    ) {
+        if ($length < 1) {
+            throw new InvalidArgumentException($option->name . ' must be greater than 0, ' . $length . ' given');
+        }
+    }
+
+    public function max(FlatColumn $column, string $bytes): string
+    {
+        if (!$this->truncates($column, $bytes)) {
+            return $bytes;
+        }
+
+        if ($this->isUtf8($column, $bytes)) {
+            $split = $this->lastCharBoundary($bytes, max(0, $this->length - 3), $this->length);
+
+            return $split === null ? $bytes : $this->incrementUtf8(substr($bytes, 0, $split)) ?? $bytes;
+        }
+
+        return $this->increment(substr($bytes, 0, $this->length)) ?? $bytes;
+    }
+
+    public function min(FlatColumn $column, string $bytes): string
+    {
+        if (!$this->truncates($column, $bytes)) {
+            return $bytes;
+        }
+
+        if ($this->isUtf8($column, $bytes)) {
+            $split = $this->lastCharBoundary($bytes, 1, $this->length);
+
+            return $split === null ? $bytes : substr($bytes, 0, $split);
+        }
+
+        return substr($bytes, 0, $this->length);
+    }
+
+    private function encodeCodePoint(int $codePoint): string
+    {
+        return match (true) {
+            $codePoint < 0x80 => chr($codePoint),
+            $codePoint < 0x800 => chr(0xC0 | ($codePoint >> 6)) . chr(0x80 | ($codePoint & 0x3F)),
+            $codePoint < 0x10000 => chr(0xE0 | ($codePoint >> 12))
+                . chr(0x80 | (($codePoint >> 6) & 0x3F))
+                . chr(0x80 | ($codePoint & 0x3F)),
+            default => chr(0xF0 | ($codePoint >> 18))
+                . chr(0x80 | (($codePoint >> 12) & 0x3F))
+                . chr(0x80 | (($codePoint >> 6) & 0x3F))
+                . chr(0x80 | ($codePoint & 0x3F)),
+        };
+    }
+
+    private function increment(string $bytes): ?string
+    {
+        for ($i = strlen($bytes) - 1; $i >= 0; $i--) {
+            $byte = ord($bytes[$i]);
+            $bytes[$i] = chr(($byte + 1) & 0xFF);
+
+            if ($byte !== 0xFF) {
+                return $bytes;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Increments the last code point that stays a valid code point of the same byte width, dropping the ones after it.
+     */
+    private function incrementUtf8(string $utf8): ?string
+    {
+        $end = strlen($utf8);
+
+        while ($end > 0) {
+            $start = $end - 1;
+
+            while ($start > 0 && (ord($utf8[$start]) & 0xC0) === 0x80) {
+                $start--;
+            }
+
+            $width = $end - $start;
+            $lead = ord($utf8[$start]);
+            $codePoint = match ($width) {
+                1 => $lead,
+                2 => $lead & 0x1F,
+                3 => $lead & 0x0F,
+                default => $lead & 0x07,
+            };
+
+            for ($i = $start + 1; $i < $end; $i++) {
+                $codePoint = ($codePoint << 6) | (ord($utf8[$i]) & 0x3F);
+            }
+
+            $next = $codePoint + 1;
+            $nextWidth = match (true) {
+                $next < 0x80 => 1,
+                $next < 0x800 => 2,
+                $next < 0x10000 => 3,
+                default => 4,
+            };
+
+            if (($next < 0xD800 || $next > 0xDFFF) && $next <= 0x10FFFF && $nextWidth === $width) {
+                return substr($utf8, 0, $start) . $this->encodeCodePoint($next);
+            }
+
+            $end = $start;
+        }
+
+        return null;
+    }
+
+    private function isUtf8(FlatColumn $column, string $bytes): bool
+    {
+        return (
+            (
+                $column->logicalType()?->is(LogicalType::STRING) === true
+                || $column->convertedType() === ConvertedType::UTF8
+            )
+            && preg_match('//u', $bytes) === 1
+        );
+    }
+
+    private function lastCharBoundary(string $utf8, int $from, int $to): ?int
+    {
+        for ($split = $to; $split >= $from; $split--) {
+            if ($split === 0 || $split === strlen($utf8) || (ord($utf8[$split]) & 0xC0) !== 0x80) {
+                return $split;
+            }
+        }
+
+        return null;
+    }
+
+    private function truncates(FlatColumn $column, string $bytes): bool
+    {
+        if (strlen($bytes) <= $this->length) {
+            return false;
+        }
+
+        return match ($column->type()) {
+            PhysicalType::BYTE_ARRAY => true,
+            PhysicalType::FIXED_LEN_BYTE_ARRAY => $column->logicalType()?->is(LogicalType::DECIMAL) !== true
+                && $column->logicalType()?->is(LogicalType::FLOAT16) !== true,
+            default => false,
+        };
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/BloomFilterBytes.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/BloomFilterBytes.php
new file mode 100644
index 0000000000..94aefdf62a
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/BloomFilterBytes.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\ThriftModel\BloomFilterAlgorithm;
+use Flow\Parquet\ThriftModel\BloomFilterCompression;
+use Flow\Parquet\ThriftModel\BloomFilterHash;
+use Flow\Parquet\ThriftModel\BloomFilterHeader;
+use Flow\Parquet\ThriftModel\SplitBlockAlgorithm;
+use Flow\Parquet\ThriftModel\Uncompressed;
+use Flow\Parquet\ThriftModel\XxHash;
+
+use function strlen;
+
+final class BloomFilterBytes
+{
+    /**
+     * A header and bitset Sbbf::serialized() never writes: the header declares $numBytes instead of the bitset's
+     * length, or another $algorithm, $hash or $compression.
+     */
+    public static function of(
+        string $bitset,
+        ?int $numBytes = null,
+        BloomFilterAlgorithm $algorithm = new BloomFilterAlgorithm(['BLOCK' => new SplitBlockAlgorithm()]),
+        BloomFilterHash $hash = new BloomFilterHash(['XXHASH' => new XxHash()]),
+        BloomFilterCompression $compression = new BloomFilterCompression(['UNCOMPRESSED' => new Uncompressed()]),
+    ): string {
+        return ThriftBytes::of(new BloomFilterHeader([
+            'numBytes' => $numBytes ?? strlen($bitset),
+            'algorithm' => $algorithm,
+            'hash' => $hash,
+            'compression' => $compression,
+        ])) . $bitset;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/BloomTruth.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/BloomTruth.php
new file mode 100644
index 0000000000..3d6ee3d64d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/BloomTruth.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\BloomEvaluator;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+
+/**
+ * The bloom truth of a filter over row group 0 of columns `i` (INT64), `f` (DOUBLE) and `s` (STRING).
+ */
+final class BloomTruth
+{
+    public static function of(Filter $filter, InMemoryIndexes $indexes): Truth
+    {
+        return BloomEvaluator::evaluate(
+            BoundFilter::bind(
+                $filter,
+                Schema::with(FlatColumn::int64('i'), FlatColumn::double('f'), FlatColumn::string('s')),
+                new Options(),
+            ),
+            $indexes,
+            0,
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/DremelPaperDocuments.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/DremelPaperDocuments.php
new file mode 100644
index 0000000000..1e507e8e4e
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/DremelPaperDocuments.php
@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\ParquetFile\Schema\Repetition;
+
+/**
+ * The two sample records of the Dremel paper and their schema.
+ */
+final class DremelPaperDocuments
+{
+    public static function schema(): Schema
+    {
+        return Schema::with(
+            FlatColumn::int32('DocId', Repetition::REQUIRED),
+            NestedColumn::list('Links', ListElement::structure([
+                NestedColumn::list('Backward', ListElement::int32()),
+                NestedColumn::list('Forward', ListElement::int32()),
+            ])),
+            NestedColumn::list(
+                'Name',
+                ListElement::structure([
+                    NestedColumn::list(
+                        'Language',
+                        ListElement::structure([
+                            FlatColumn::string('Code', Repetition::REQUIRED),
+                            FlatColumn::string('Country'),
+                        ]),
+                        Repetition::OPTIONAL,
+                    ),
+                    FlatColumn::string('Url', Repetition::OPTIONAL),
+                ]),
+                Repetition::OPTIONAL,
+            ),
+        );
+    }
+
+    /**
+     * @return list<array<string, mixed>>
+     */
+    public static function rows(): array
+    {
+        return [
+            [
+                'DocId' => 10,
+                'Links' => [
+                    [
+                        'Forward' => [20, 40, 60],
+                        'Backward' => null,
+                    ],
+                ],
+                'Name' => [
+                    [
+                        'Url' => 'http://A',
+                        'Language' => [
+                            ['Code' => 'en-us', 'Country' => 'us'],
+                            ['Code' => 'en', 'Country' => null],
+                        ],
+                    ],
+                    [
+                        'Url' => 'http://B',
+                        'Language' => null,
+                    ],
+                    [
+                        'Url' => null,
+                        'Language' => [
+                            ['Code' => 'en-gb', 'Country' => 'gb'],
+                        ],
+                    ],
+                ],
+            ],
+            [
+                'DocId' => 20,
+                'Links' => [
+                    [
+                        'Backward' => [10, 30],
+                        'Forward' => [80],
+                    ],
+                ],
+                'Name' => [
+                    [
+                        'Url' => 'http://C',
+                        'Language' => null,
+                    ],
+                ],
+            ],
+        ];
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilePlan.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilePlan.php
new file mode 100644
index 0000000000..e5fee06318
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilePlan.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile;
+use Flow\Parquet\ParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\ReadPlanner;
+
+use function array_keys;
+
+/**
+ * The read the adapter does: ReadPlanner's plan, its bound conjuncts filtered row by row, read through the reader.
+ */
+final class FilePlan
+{
+    /**
+     * @param ParquetFile<ParquetFileReader> $file
+     */
+    public static function of(ParquetFile $file, ?Filter $filter = null, int $offset = 0): ReadPlan
+    {
+        $footer = $file->reader()->footer();
+
+        return (new ReadPlanner())->plan(
+            $footer,
+            $file->indexes(),
+            $filter === null ? null : BoundFilter::bind($filter, $footer->schema(), new Options()),
+            $offset,
+        );
+    }
+
+    /**
+     * @param ParquetFile<ParquetFileReader> $file
+     * @param list<string> $columns
+     *
+     * @return list<array<string, mixed>>
+     */
+    public static function rows(ParquetFile $file, array $columns, ReadPlan $plan): array
+    {
+        $rows = [];
+
+        foreach ($file->reader()->readColumns($columns, 1024, $plan) as $chunk) {
+            foreach (array_keys($chunk[$columns[0]]) as $index) {
+                $row = [];
+
+                foreach ($columns as $column) {
+                    $row[$column] = $chunk[$column][$index];
+                }
+
+                $rows[] = $row;
+            }
+        }
+
+        return $rows;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilterExpectations.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilterExpectations.php
new file mode 100644
index 0000000000..ab1a18edea
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilterExpectations.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\FilterEvaluator;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\Reader\RowSelection;
+
+use function array_values;
+use function intdiv;
+
+final class FilterExpectations
+{
+    /**
+     * The row groups a selection reads rows of.
+     *
+     * @return list<int>
+     */
+    public static function keptGroups(RowSelection $selection, int $rowsPerGroup): array
+    {
+        $rowCounts = [];
+
+        for ($covered = 0; $covered < $selection->totalRows(); $covered += $rowsPerGroup) {
+            $rowCounts[] = $rowsPerGroup;
+        }
+
+        $kept = [];
+
+        foreach ($selection->split($rowCounts) as $group => $rows) {
+            if ($rows->selectsAny()) {
+                $kept[] = $group;
+            }
+        }
+
+        return $kept;
+    }
+
+    /**
+     * The row groups holding a row, from `$offset` on, the filter keeps by FilterEvaluator.
+     *
+     * @param iterable<array<string, mixed>> $rows
+     *
+     * @return list<int>
+     */
+    public static function matchingGroups(
+        iterable $rows,
+        Filter $filter,
+        Schema $schema,
+        int $rowsPerGroup,
+        int $offset = 0,
+    ): array {
+        $groups = [];
+
+        foreach (self::matchingIds($rows, $filter, $schema, $offset) as $id) {
+            $groups[intdiv($id, $rowsPerGroup)] = intdiv($id, $rowsPerGroup);
+        }
+
+        return array_values($groups);
+    }
+
+    /**
+     * The ids of the rows, from `$offset` on, the filter keeps by FilterEvaluator.
+     *
+     * @param iterable<array<string, mixed>> $rows
+     *
+     * @return list<int>
+     */
+    public static function matchingIds(iterable $rows, Filter $filter, Schema $schema, int $offset = 0): array
+    {
+        $batch = [];
+        $index = 0;
+
+        foreach ($rows as $row) {
+            if ($index++ < $offset) {
+                continue;
+            }
+
+            // @mago-ignore analysis:mixed-assignment
+            foreach ($row as $column => $value) {
+                $batch[$column][] = $value;
+            }
+        }
+
+        $ids = [];
+
+        foreach ((new FilterEvaluator(BoundFilter::bind($filter, $schema, new Options())))->mask($batch) as $row) {
+            /** @var int $id */
+            $id = $batch['id'][$row];
+            $ids[] = $id;
+        }
+
+        return $ids;
+    }
+
+    /**
+     * The ids of the rows a read returned.
+     *
+     * @param iterable<array<string, mixed>> $rows
+     *
+     * @return list<int>
+     */
+    public static function ids(iterable $rows): array
+    {
+        $ids = [];
+
+        foreach ($rows as $row) {
+            /** @var int $id */
+            $id = $row['id'];
+            $ids[] = $id;
+        }
+
+        return $ids;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilterRows.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilterRows.php
new file mode 100644
index 0000000000..1764122382
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/FilterRows.php
@@ -0,0 +1,259 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use DateTimeImmutable;
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetEngine;
+use Flow\Parquet\ParquetFile;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFileReader;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Mother\ParquetEngineMother;
+use Flow\Parquet\Writer;
+
+use function bcsub;
+use function file_get_contents;
+use function intdiv;
+use function is_array;
+use function preg_match;
+use function sprintf;
+
+use const NAN;
+
+/**
+ * The rows of the Filters files: four row groups of `$rowsPerGroup` rows, row i has id i. The PHP and arrow files hold
+ * groups of 10; the DuckDB one groups of 2048, the smallest DuckDB writes.
+ */
+final class FilterRows
+{
+    public const string FIXTURES = __DIR__ . '/../Integration/Engine/Fixtures/Filters/';
+
+    public const int DUCKDB_BLOOM_ROWS = 8192;
+
+    public const int DUCKDB_ROWS_PER_GROUP = 2048;
+
+    public const int ROWS_PER_GROUP = 10;
+
+    public const int ROWS_PER_PAGE = 5;
+
+    /**
+     * @return list<array<string, mixed>>
+     */
+    public static function rows(int $rowsPerGroup = self::ROWS_PER_GROUP): array
+    {
+        $rows = [];
+
+        for ($i = 0; $i < (4 * $rowsPerGroup); $i++) {
+            $group = intdiv($i, $rowsPerGroup);
+            $rows[] = [
+                'id' => $i,
+                'label' => match ($group) {
+                    0 => '9',
+                    1 => '10',
+                    2 => '100',
+                    default => ['9', '10', '100'][$i % 3],
+                },
+                'score' => match (true) {
+                    $i === $rowsPerGroup => -0.0,
+                    $i === ($rowsPerGroup + 1) || $group === 2 => NAN,
+                    default => (float) $i,
+                },
+                'maybe' => $group === 0 || $group === 1 && ($i % 2) === 1 ? null : $i,
+                'day' => new DateTimeImmutable(sprintf('2024-01-01 +%d days UTC', $i)),
+                'ts' => new DateTimeImmutable(sprintf('2024-01-01 00:00:00.123456 +%d hours UTC', $i)),
+                'amount' => $i + 0.25,
+                'address' => $group === 3 && ($i % 5) === 0 ? null : ['city' => 'c' . $group],
+                'big' => $group >= 2
+                    ? bcsub('18446744073709551615', (string) ((4 * $rowsPerGroup) - 1 - $i))
+                    : (string) $i,
+                'uid' => sprintf('%08x-0000-4000-8000-%012x', $group, $i),
+                'flag' => match ($group) {
+                    0 => false,
+                    1 => true,
+                    default => ($i % 2) === 0,
+                },
+                'ratio' => $i + 0.5,
+                'word' => match ($group) {
+                    0 => 'ąbc',
+                    1 => 'źdźbło',
+                    2 => 'zebra',
+                    default => ['ąbc', 'źdźbło', 'zebra'][$i % 3],
+                },
+            ];
+        }
+
+        return $rows;
+    }
+
+    public static function schema(): Schema
+    {
+        return Schema::with(
+            FlatColumn::int64('id'),
+            FlatColumn::string('label'),
+            FlatColumn::double('score'),
+            FlatColumn::int64('maybe'),
+            FlatColumn::date('day'),
+            FlatColumn::dateTime('ts'),
+            FlatColumn::decimal('amount', 10, 2),
+            NestedColumn::struct('address', [FlatColumn::string('city')]),
+            new FlatColumn('big', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            FlatColumn::uuid('uid'),
+            FlatColumn::boolean('flag'),
+            FlatColumn::float('ratio'),
+            FlatColumn::string('word'),
+        );
+    }
+
+    /**
+     * The rows of the bloom files: even ids only, so an odd id lies inside every group's min/max and
+     * only a bloom filter proves it absent; key is 'k' followed by id.
+     *
+     * @return list<array{id: int, key: string}>
+     */
+    public static function bloomRows(int $rows = 4 * self::ROWS_PER_GROUP): array
+    {
+        $bloomRows = [];
+
+        for ($i = 0; $i < $rows; $i++) {
+            $bloomRows[] = ['id' => $i * 2, 'key' => 'k' . ($i * 2)];
+        }
+
+        return $bloomRows;
+    }
+
+    public static function bloomSchema(): Schema
+    {
+        return Schema::with(FlatColumn::int64('id'), FlatColumn::string('key'));
+    }
+
+    /**
+     * The rows of the pages files (40 rows, one row group, pages of 5 rows): `address` holds a list
+     * `codes` beside `city`, id % 4 copies of id, empty when id % 4 is 0.
+     *
+     * @return list<array<string, mixed>>
+     */
+    public static function pageRows(): array
+    {
+        $rows = [];
+
+        foreach (self::rows() as $row) {
+            /** @var int $id */
+            $id = $row['id'];
+            $codes = [];
+
+            for ($code = 0; $code < ($id % 4); $code++) {
+                $codes[] = $id;
+            }
+
+            if (is_array($row['address'])) {
+                $row['address']['codes'] = $codes;
+            }
+
+            $rows[] = $row;
+        }
+
+        return $rows;
+    }
+
+    public static function pageSchema(): Schema
+    {
+        return Schema::with(
+            FlatColumn::int64('id'),
+            FlatColumn::string('label'),
+            FlatColumn::double('score'),
+            FlatColumn::int64('maybe'),
+            FlatColumn::date('day'),
+            FlatColumn::dateTime('ts'),
+            FlatColumn::decimal('amount', 10, 2),
+            NestedColumn::struct('address', [
+                FlatColumn::string('city'),
+                NestedColumn::list('codes', ListElement::int64()),
+            ]),
+            new FlatColumn('big', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            FlatColumn::uuid('uid'),
+            FlatColumn::boolean('flag'),
+            FlatColumn::float('ratio'),
+            FlatColumn::string('word'),
+        );
+    }
+
+    /**
+     * The bytes of a Filters file: `row_groups`, `pages` or `bloom` with `_php` or `_arrow`, written in memory by that
+     * writer, or one of FIXTURES by its name.
+     *
+     * @return non-empty-string
+     */
+    public static function bytes(string $fixture): string
+    {
+        $written = [];
+
+        if (preg_match('/^(row_groups|pages|bloom)_(php|arrow)$/', $fixture, $written) !== 1) {
+            $bytes = file_get_contents(self::FIXTURES . $fixture . '.parquet');
+
+            return $bytes === false || $bytes === ''
+                ? throw new InvalidArgumentException('No fixture ' . $fixture)
+                : $bytes;
+        }
+
+        $options = match ($written[1]) {
+            'pages' => Options::default()->set(Option::PAGE_SIZE_BYTES, 1)->set(
+                Option::PAGE_SIZE_CHECK_INTERVAL,
+                self::ROWS_PER_PAGE,
+            )->set(Option::ARROW_WRITE_BATCH_SIZE, self::ROWS_PER_PAGE),
+            default => Options::default()
+                ->set(Option::ROW_GROUP_SIZE_BYTES, 1)
+                ->set(Option::ROW_GROUP_SIZE_CHECK_INTERVAL, self::ROWS_PER_GROUP)
+                ->set(Option::PAGE_SIZE_BYTES, 1)
+                ->set(Option::PAGE_SIZE_CHECK_INTERVAL, self::ROWS_PER_GROUP)
+                ->set(Option::ARROW_WRITE_BATCH_SIZE, self::ROWS_PER_GROUP)
+                ->set(
+                    Option::COLUMNS_BLOOM_FILTERS,
+                    $written[1] === 'bloom'
+                        ? ['id' => new BloomFilterOptions(), 'key' => new BloomFilterOptions()]
+                        : null,
+                ),
+        };
+
+        return MemoryParquetFile::written(
+            new Writer(
+                options: $options,
+                engine: $written[2] === 'php' ? new PhpParquetEngine() : new RustParquetEngine($options),
+            ),
+            match ($written[1]) {
+                'pages' => self::pageSchema(),
+                'bloom' => self::bloomSchema(),
+                default => self::schema(),
+            },
+            match ($written[1]) {
+                'pages' => self::pageRows(),
+                'bloom' => self::bloomRows(),
+                default => self::rows(),
+            },
+        );
+    }
+
+    /**
+     * A Filters file (see bytes()) read by $engine.
+     *
+     * @param class-string<ParquetEngine> $engine
+     *
+     * @return ParquetFile<ParquetFileReader>
+     */
+    public static function file(string $fixture, string $engine): ParquetFile
+    {
+        return MemoryParquetFile::read(new Reader(engine: ParquetEngineMother::create($engine)), self::bytes($fixture));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/MemoryParquetFile.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/MemoryParquetFile.php
index f489726394..9d33a43ff3 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/MemoryParquetFile.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/MemoryParquetFile.php
@@ -10,17 +10,28 @@
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile;
+use Flow\Parquet\ParquetFile\Encodings;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
 use Flow\Parquet\ParquetFileReader;
 use Flow\Parquet\Reader;
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
+use Flow\Parquet\ThriftModel\FileMetaData;
 use Flow\Parquet\Writer;
 
+use function array_column;
 use function array_map;
+use function array_values;
 use function Flow\Filesystem\DSL\path;
+use function iterator_to_array;
+use function pack;
 use function range;
+use function strlen;
+use function substr;
+use function unpack;
 
 /**
  * Parquet files written to and read from memory, never the filesystem.
@@ -47,6 +58,92 @@ public static function threeRowGroups(): string
         );
     }
 
+    /**
+     * The values of one column of the file, read through $reader.
+     *
+     * @param non-empty-string $bytes
+     *
+     * @return list<mixed>
+     */
+    public static function column(Reader $reader, string $bytes, string $column): array
+    {
+        return array_values(array_column(iterator_to_array(self::read($reader, $bytes)->values(), false), $column));
+    }
+
+    /**
+     * A string column `s`, RLE_DICTIONARY encoded, two values per page.
+     *
+     * @param list<?string> $values
+     *
+     * @return non-empty-string
+     */
+    public static function dictionaryColumn(array $values, Options $options): string
+    {
+        return self::written(
+            Writer::php(options: $options->set(Option::PAGE_SIZE_BYTES, 8)->set(
+                Option::PAGE_SIZE_CHECK_INTERVAL,
+                2,
+            )->set(Option::COLUMNS_ENCODINGS, ['s' => Encodings::RLE_DICTIONARY])),
+            Schema::with(FlatColumn::string('s')),
+            array_map(static fn(?string $value): array => ['s' => $value], $values),
+        );
+    }
+
+    /**
+     * One row group of 12 rows, two rows per page: `id` (INT64 0-11, PLAIN), `word` (RLE_DICTIONARY, "w{id % 3}") and
+     * `tags` (a list of id % 3 + 1 ints, `id` repeated).
+     *
+     * @return non-empty-string
+     */
+    public static function pagedColumns(): string
+    {
+        return self::written(
+            Writer::php(options: (new Options())->set(Option::PAGE_SIZE_BYTES, 16)->set(
+                Option::PAGE_SIZE_CHECK_INTERVAL,
+                2,
+            )->set(Option::COLUMNS_ENCODINGS, ['word' => Encodings::RLE_DICTIONARY])),
+            Schema::with(
+                FlatColumn::int64('id'),
+                FlatColumn::string('word'),
+                NestedColumn::list('tags', ListElement::int64()),
+            ),
+            array_map(
+                static fn(int $id): array => [
+                    'id' => $id,
+                    'word' => 'w' . ($id % 3),
+                    'tags' => array_map(static fn(): int => $id, range(0, $id % 3)),
+                ],
+                range(0, 11),
+            ),
+        );
+    }
+
+    /**
+     * The file with every column chunk recording a bloom filter length but no offset.
+     *
+     * @param non-empty-string $bytes
+     *
+     * @return non-empty-string
+     */
+    public static function bloomFilterLengthWithoutOffset(string $bytes): string
+    {
+        $footerLength = unpack('V', substr($bytes, -8, 4))[1];
+        $metadata = new FileMetaData();
+        $metadata->read(new CompactProtocol(new MemoryBuffer(substr($bytes, -8 - $footerLength, $footerLength))));
+
+        foreach ($metadata->row_groups as $rowGroup) {
+            foreach ($rowGroup->columns as $column) {
+                $chunk = $column->meta_data ?? throw new RuntimeException('No column metadata');
+                $chunk->bloom_filter_offset = null;
+                $chunk->bloom_filter_length = 48;
+            }
+        }
+
+        $metadata->write(new CompactProtocol($buffer = new MemoryBuffer()));
+
+        return substr($bytes, 0, -8 - $footerLength) . $buffer->data() . pack('V', strlen($buffer->data())) . 'PAR1';
+    }
+
     /**
      * @param non-empty-string $bytes
      *
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/OneGroupPagePruning.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/OneGroupPagePruning.php
new file mode 100644
index 0000000000..3e8fed20c1
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/OneGroupPagePruning.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader\Pruning\PageIndexPruner;
+use Flow\Parquet\Reader\Pruning\PrunedRows;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Mother\FooterMother;
+
+/**
+ * The page index pruning of one row group of 10 rows over INT64 columns `a` and `b`.
+ */
+final class OneGroupPagePruning
+{
+    public static function pruned(Filter $filter, InMemoryIndexes $indexes, ?PrunedRows $rows = null): PrunedRows
+    {
+        $footer = FooterMother::oneGroup(10, FlatColumn::int64('a'), FlatColumn::int64('b'));
+
+        return (new PageIndexPruner(new MetadataRowGroupChunks($footer->metadata()), $indexes))->prune(
+            BoundFilter::bind($filter, $footer->schema(), new Options()),
+            $rows ?? new PrunedRows(RowSelection::all(10), RowSelection::none(10)),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PaginationFixture.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PaginationFixture.php
new file mode 100644
index 0000000000..14e83afd0e
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PaginationFixture.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use DateTimeImmutable;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\MapKey;
+use Flow\Parquet\ParquetFile\Schema\MapValue;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Writer;
+
+use function array_map;
+use function array_merge;
+use function file_exists;
+use function Flow\ETL\DSL\generate_random_int;
+use function range;
+use function unlink;
+
+/**
+ * Writes Integration/IO/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet: 5000 rows in row groups of 1 KB.
+ */
+final class PaginationFixture
+{
+    public static function write(string $path): void
+    {
+        $writer = new Writer(options: Options::default()->set(Option::ROW_GROUP_SIZE_BYTES, 1024)->set(
+            Option::ROW_GROUP_SIZE_CHECK_INTERVAL,
+            100,
+        ));
+        $schema = Schema::with(
+            FlatColumn::int64('id'),
+            FlatColumn::string('name'),
+            FlatColumn::boolean('active'),
+            FlatColumn::dateTime('created_at'),
+            NestedColumn::list('list_of_int', ListElement::int32()),
+            NestedColumn::map('map_of_int_string', MapKey::int32(), MapValue::string()),
+            NestedColumn::struct('struct', [
+                FlatColumn::int64('id'),
+                FlatColumn::string('name'),
+                FlatColumn::boolean('active'),
+                FlatColumn::dateTime('created_at'),
+                NestedColumn::list('list_of_int', ListElement::int32()),
+                NestedColumn::map('map_of_int_string', MapKey::int32(), MapValue::string()),
+            ]),
+        );
+
+        $inputData = array_merge(...array_map(
+            static fn(int $i): array => [
+                [
+                    'id' => $i,
+                    'name' => 'name-' . $i,
+                    'active' => ($i % 2) === 0,
+                    'created_at' => new DateTimeImmutable('2024-01-01 + ' . $i . ' days'),
+                    'list_of_int' => array_map(static fn(int $i) => $i, range(1, generate_random_int(2, 10))),
+                    'map_of_int_string' => array_merge(...array_map(
+                        static fn(int $i) => [$i => 'value-' . $i],
+                        range(1, generate_random_int(2, 10)),
+                    )),
+                    'struct' => [
+                        'id' => $i,
+                        'name' => 'name-' . $i,
+                        'active' => ($i % 2) === 0,
+                        'created_at' => new DateTimeImmutable('2024-01-01 + ' . $i . ' days'),
+                        'list_of_int' => array_map(static fn(int $i) => $i, range(1, generate_random_int(2, 10))),
+                        'map_of_int_string' => array_merge(...array_map(
+                            static fn(int $i) => [$i => 'value-' . $i],
+                            range(1, generate_random_int(2, 10)),
+                        )),
+                    ],
+                ],
+            ],
+            range(0, 4999),
+        ));
+
+        if (file_exists($path)) {
+            unlink($path);
+        }
+
+        $writer->write($path, $schema, $inputData);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ParquetRows.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ParquetRows.php
index d07045df5e..abfa2ef84f 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ParquetRows.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ParquetRows.php
@@ -6,6 +6,7 @@
 
 use Flow\Parquet\ParquetFile;
 use Flow\Parquet\ParquetFileReader;
+use Flow\Parquet\Query;
 
 use function array_keys;
 use function count;
@@ -31,7 +32,7 @@ public static function read(
     ): array {
         $rows = [];
 
-        foreach ($file->columns($batchSize, $columns, $limit, $offset) as $chunk) {
+        foreach ($file->columns(new Query($columns, offset: $offset ?? 0, limit: $limit), $batchSize) as $chunk) {
             $names = array_keys($chunk);
 
             for ($i = 0, $count = count($chunk[$names[0]]); $i < $count; $i++) {
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PhysicalIntervalEdges.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PhysicalIntervalEdges.php
new file mode 100644
index 0000000000..4031de1685
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PhysicalIntervalEdges.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use DateTimeImmutable;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\PhysicalInterval;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function array_map;
+
+final class PhysicalIntervalEdges
+{
+    /**
+     * Each interval as [lower, lowerInclusive, upper, upperInclusive]; null when the intervals are.
+     *
+     * @return null|list<array{0: null|bool|float|int|string, 1: bool, 2: null|bool|float|int|string, 3: bool}>
+     */
+    public static function of(?PhysicalIntervals $intervals): ?array
+    {
+        return $intervals === null
+            ? null
+            : array_map(static fn(PhysicalInterval $interval): array => [
+                $interval->lower,
+                $interval->lowerInclusive,
+                $interval->upper,
+                $interval->upperInclusive,
+            ], $intervals->intervals);
+    }
+
+    /**
+     * The edges of the column's pre-image of `$operator $literal`, through the converter that decodes the column.
+     *
+     * @return null|list<array{0: null|bool|float|int|string, 1: bool, 2: null|bool|float|int|string, 3: bool}>
+     */
+    public static function ofComparison(
+        FlatColumn $column,
+        Operator $operator,
+        bool|DateTimeImmutable|float|int|string $literal,
+    ): ?array {
+        return self::of(self::intervals($column, $operator, $literal));
+    }
+
+    public static function intervals(
+        FlatColumn $column,
+        Operator $operator,
+        bool|DateTimeImmutable|float|int|string $literal,
+    ): ?PhysicalIntervals {
+        [, $preImage] = LiteralDomain::forColumn(
+            $column,
+            DataConverter::initialize(new Options())->resolveConverter($column),
+        );
+
+        return $preImage === null
+            ? null
+            : PhysicalIntervals::preImage($preImage, PhysicalOrder::forColumn($column), $operator, $literal);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PreImageDifferential.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PreImageDifferential.php
new file mode 100644
index 0000000000..d47e6b171e
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/PreImageDifferential.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\Evaluation\FilterEvaluator;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+use function bin2hex;
+use function Flow\Parquet\DSL\parquet_column;
+use function is_string;
+use function sprintf;
+use function var_export;
+
+/**
+ * Each physical value against each comparison: inside the pre-image exactly when its decoded value matches.
+ */
+final class PreImageDifferential
+{
+    /**
+     * Every physical value whose membership disagrees with the reference semantics, as "operator literal: value".
+     *
+     * @param list<bool|float|int|string> $physicals
+     * @param list<bool|DateTimeImmutable|float|int|string> $literals
+     *
+     * @return list<string>
+     */
+    public static function mismatches(FlatColumn $column, array $physicals, array $literals): array
+    {
+        $converter = DataConverter::initialize(new Options())->resolveConverter($column);
+        $mismatches = [];
+
+        foreach ($literals as $literal) {
+            foreach (Operator::cases() as $operator) {
+                $intervals = PhysicalIntervalEdges::intervals($column, $operator, $literal);
+
+                if ($intervals === null) {
+                    continue;
+                }
+
+                $comparison = new Comparison(parquet_column($column->name()), $operator, $literal);
+
+                foreach ($physicals as $physical) {
+                    $matches = (new FilterEvaluator(BoundFilter::bind(
+                        $comparison,
+                        Schema::with($column),
+                        new Options(),
+                    )))->mask([
+                        $column->name() => [$converter === null ? $physical : $converter->fromParquetType($physical)],
+                    ]) === [0];
+
+                    if ($matches !== $intervals->covers($physical, $physical)) {
+                        $mismatches[] = sprintf(
+                            '%s %s: %s',
+                            $operator->name,
+                            $literal instanceof DateTimeImmutable
+                                ? $literal->format('Y-m-d H:i:s.uP')
+                                : var_export($literal, true),
+                            is_string($physical) ? bin2hex($physical) : var_export($physical, true),
+                        );
+                    }
+                }
+            }
+        }
+
+        return $mismatches;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/StatisticsParityRows.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/StatisticsParityRows.php
new file mode 100644
index 0000000000..5c1868dde4
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/StatisticsParityRows.php
@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use DateTimeImmutable;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\ParquetEngine;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Writer;
+
+use function str_repeat;
+
+use const NAN;
+
+final class StatisticsParityRows
+{
+    /**
+     * @return list<array<string, mixed>>
+     */
+    public static function rows(): array
+    {
+        return [
+            [
+                'digits' => '9',
+                'long' => str_repeat('a', 101),
+                'double' => -0.0,
+                'float' => 1.5,
+                'decimal' => -3.5,
+                'int32' => 7,
+                'int64' => 1,
+                'uint64' => 0,
+                'boolean' => true,
+                'date' => new DateTimeImmutable('2024-01-02'),
+                'uuid' => 'ffffffff-0000-0000-0000-000000000001',
+                'decimal30' => -3.5,
+                'binary' => "\x00\xff",
+                'timestamp' => new DateTimeImmutable('2024-01-02 03:04:05.123456 UTC'),
+                'enum' => 'RED',
+            ],
+            [
+                'digits' => '10',
+                'long' => str_repeat('c', 101),
+                'double' => NAN,
+                'float' => NAN,
+                'decimal' => 1.25,
+                'int32' => null,
+                'int64' => null,
+                'uint64' => '18446744073709551615',
+                'boolean' => false,
+                'date' => null,
+                'uuid' => null,
+                'decimal30' => 12_345_678_901_234_567.25,
+                'binary' => "\x80",
+                'timestamp' => null,
+                'enum' => 'BLUE',
+            ],
+            [
+                'digits' => '100',
+                'long' => str_repeat('b', 101),
+                'double' => 0.0,
+                'float' => -2.0,
+                'decimal' => null,
+                'int32' => -7,
+                'int64' => 3,
+                'uint64' => 5,
+                'boolean' => null,
+                'date' => new DateTimeImmutable('1999-12-31'),
+                'uuid' => '00000000-0000-0000-0000-000000000002',
+                'decimal30' => null,
+                'binary' => "\x7f",
+                'timestamp' => new DateTimeImmutable('1969-12-31 23:59:59 UTC'),
+                'enum' => 'GREEN',
+            ],
+        ];
+    }
+
+    public static function schema(): Schema
+    {
+        return Schema::with(
+            FlatColumn::string('digits'),
+            FlatColumn::string('long'),
+            FlatColumn::double('double'),
+            FlatColumn::float('float'),
+            FlatColumn::decimal('decimal', 10, 2),
+            FlatColumn::int32('int32'),
+            FlatColumn::int64('int64'),
+            new FlatColumn('uint64', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            FlatColumn::boolean('boolean'),
+            FlatColumn::date('date'),
+            FlatColumn::uuid('uuid'),
+            FlatColumn::decimal('decimal30', 30, 2),
+            new FlatColumn('binary', PhysicalType::BYTE_ARRAY),
+            FlatColumn::dateTime('timestamp'),
+            FlatColumn::enum('enum'),
+        );
+    }
+
+    /**
+     * Per leaf flat path, the column chunk statistics `engine` writes for these rows, read back by the PHP footer
+     * decoder: min, max, min_value, max_value, null_count, nan_count, exactness flags and the column order.
+     *
+     * @return array<string, list<mixed>>
+     */
+    public static function statistics(ParquetEngine $engine): array
+    {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+            new Writer(engine: $engine),
+            self::schema(),
+            self::rows(),
+        ))->metadata();
+        $statistics = [];
+
+        foreach ($metadata->schema()->columnsFlat() as $index => $column) {
+            $chunk = $metadata->columnChunks()[$index]->statistics() ?? throw new RuntimeException(
+                'Column "' . $column->flatPath() . '" has no statistics',
+            );
+            $statistics[$column->flatPath()] = [
+                $chunk->min($column),
+                $chunk->max($column),
+                $chunk->minValue($column),
+                $chunk->maxValue($column),
+                $chunk->nullCount(),
+                $chunk->nanCount(),
+                $chunk->isMinValueExact(),
+                $chunk->isMaxValueExact(),
+                $metadata->columnOrder($column),
+            ];
+        }
+
+        return $statistics;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/StructWithLists.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/StructWithLists.php
new file mode 100644
index 0000000000..d814d5e327
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/StructWithLists.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Faker\Factory;
+use Flow\Parquet\Consts;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+
+use function array_map;
+use function Flow\ETL\DSL\generate_random_int;
+use function range;
+
+/**
+ * A struct of scalars and two lists, with random rows of that shape.
+ */
+final class StructWithLists
+{
+    /**
+     * @return array<string, mixed>
+     */
+    public static function row(): array
+    {
+        $faker = Factory::create();
+
+        return [
+            'struct' => [
+                'int64' => $faker->numberBetween(0, Consts::PHP_INT64_MAX),
+                'boolean' => $faker->boolean(),
+                'string' => $faker->text(150),
+                'int32' => $faker->numberBetween(0, Consts::PHP_INT32_MAX),
+                'list_of_int' => array_map(
+                    static fn($i) => $faker->numberBetween(0, Consts::PHP_INT32_MAX),
+                    range(1, generate_random_int(2, 10)),
+                ),
+                'list_of_string' => array_map(static fn($i) => $faker->text(10), range(1, generate_random_int(2, 10))),
+            ],
+        ];
+    }
+
+    public static function schema(): Schema
+    {
+        return Schema::with(NestedColumn::struct('struct', [
+            FlatColumn::int64('int64'),
+            FlatColumn::boolean('boolean'),
+            FlatColumn::string('string'),
+            FlatColumn::int32('int32'),
+            NestedColumn::list('list_of_int', ListElement::int32()),
+            NestedColumn::list('list_of_string', ListElement::string()),
+        ]));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ThreeRowGroupsPruning.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ThreeRowGroupsPruning.php
new file mode 100644
index 0000000000..d86b756801
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ThreeRowGroupsPruning.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\Pruning\PrunedRows;
+use Flow\Parquet\Reader\Pruning\RowGroupStatisticsPruner;
+use Flow\Parquet\Reader\RowSelection;
+
+/**
+ * The row-group statistics pruning of `MemoryParquetFile::threeRowGroups()`.
+ */
+final class ThreeRowGroupsPruning
+{
+    public static function chunks(): MetadataRowGroupChunks
+    {
+        return new MetadataRowGroupChunks(
+            MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata(),
+        );
+    }
+
+    public static function pruned(
+        Filter $filter,
+        RowSelection $selected,
+        ?RowSelection $matched = null,
+        ?RowGroupChunks $chunks = null,
+    ): PrunedRows {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata();
+
+        return (new RowGroupStatisticsPruner($chunks ?? new MetadataRowGroupChunks($metadata)))->prune(
+            BoundFilter::bind($filter, $metadata->schema(), new Options()),
+            new PrunedRows($selected, $matched ?? RowSelection::none(6)),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ThriftBytes.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ThriftBytes.php
new file mode 100644
index 0000000000..11c2a84a31
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ThriftBytes.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Thrift\CompactProtocol;
+use Flow\Parquet\Thrift\MemoryBuffer;
+use Flow\Parquet\ThriftModel\BloomFilterHeader;
+use Flow\Parquet\ThriftModel\ColumnChunk;
+use Flow\Parquet\ThriftModel\ColumnIndex;
+use Flow\Parquet\ThriftModel\ColumnOrder;
+use Flow\Parquet\ThriftModel\OffsetIndex;
+use Flow\Parquet\ThriftModel\PageHeader;
+
+final class ThriftBytes
+{
+    /**
+     * The compact-protocol bytes of a thrift struct, as a file holds them.
+     */
+    public static function of(BloomFilterHeader|ColumnChunk|ColumnIndex|ColumnOrder|OffsetIndex|PageHeader $struct): string
+    {
+        $struct->write(new CompactProtocol($buffer = new MemoryBuffer()));
+
+        return $buffer->data();
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ZoneTruth.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ZoneTruth.php
new file mode 100644
index 0000000000..61fc9a91b8
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Context/ZoneTruth.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Context;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\StatisticsEvaluator;
+use Flow\Parquet\Filter\Evaluation\ZoneMap;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Double\ColumnZoneMaps;
+
+/**
+ * The truth of a filter over one unit whose columns are `i` (INT64), `f` (DOUBLE) and `s` (STRING).
+ */
+final class ZoneTruth
+{
+    /**
+     * @param array<string, ZoneMap> $zones
+     */
+    public static function of(Filter $filter, array $zones): Truth
+    {
+        return StatisticsEvaluator::evaluate(
+            BoundFilter::bind(
+                $filter,
+                Schema::with(FlatColumn::int64('i'), FlatColumn::double('f'), FlatColumn::string('s')),
+                new Options(),
+            ),
+            new ColumnZoneMaps($zones),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/ColumnZoneMaps.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/ColumnZoneMaps.php
new file mode 100644
index 0000000000..46c6275f45
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/ColumnZoneMaps.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Double;
+
+use Flow\Parquet\Filter\Evaluation\ZoneMap;
+use Flow\Parquet\Filter\Evaluation\ZoneMaps;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+/**
+ * A zone per flat path; a column without one has no usable statistics.
+ */
+final readonly class ColumnZoneMaps implements ZoneMaps
+{
+    /**
+     * @param array<string, ZoneMap> $zones
+     */
+    public function __construct(
+        public array $zones,
+    ) {}
+
+    public function zone(FlatColumn $column): ?ZoneMap
+    {
+        return $this->zones[$column->flatPath()] ?? null;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/InMemoryIndexes.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/InMemoryIndexes.php
new file mode 100644
index 0000000000..42732f9ccf
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/InMemoryIndexes.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Double;
+
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\ParquetFile\Index\Indexes;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+/**
+ * Answers from the indexes it is given, keyed by flat path then row group; records every lookup as [method, path, row group].
+ */
+final class InMemoryIndexes implements Indexes
+{
+    /**
+     * @var list<array{string, string, int}>
+     */
+    public array $reads = [];
+
+    /**
+     * @param array<string, array<int, ColumnIndex>> $columnIndexes
+     * @param array<string, array<int, OffsetIndex>> $offsetIndexes
+     * @param array<string, array<int, Sbbf>> $bloomFilters
+     */
+    public function __construct(
+        private readonly array $columnIndexes = [],
+        private readonly array $offsetIndexes = [],
+        private readonly array $bloomFilters = [],
+    ) {}
+
+    public function bloomFilter(int $rowGroup, FlatColumn $column): ?Sbbf
+    {
+        $this->reads[] = ['bloomFilter', $column->flatPath(), $rowGroup];
+
+        return $this->bloomFilters[$column->flatPath()][$rowGroup] ?? null;
+    }
+
+    public function columnIndex(int $rowGroup, FlatColumn $column): ?ColumnIndex
+    {
+        $this->reads[] = ['columnIndex', $column->flatPath(), $rowGroup];
+
+        return $this->columnIndexes[$column->flatPath()][$rowGroup] ?? null;
+    }
+
+    public function offsetIndex(int $rowGroup, FlatColumn $column): ?OffsetIndex
+    {
+        $this->reads[] = ['offsetIndex', $column->flatPath(), $rowGroup];
+
+        return $this->offsetIndexes[$column->flatPath()][$rowGroup] ?? null;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/NodeNameVisitor.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/NodeNameVisitor.php
new file mode 100644
index 0000000000..5578048b84
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/NodeNameVisitor.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Double;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\FilterVisitor;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\StartsWith;
+
+/**
+ * Answers the name of the visitor method a node called.
+ *
+ * @implements FilterVisitor<string>
+ */
+final class NodeNameVisitor implements FilterVisitor
+{
+    public function comparison(Comparison $comparison): string
+    {
+        return 'comparison';
+    }
+
+    public function all(All $all): string
+    {
+        return 'all';
+    }
+
+    public function any(Any $any): string
+    {
+        return 'any';
+    }
+
+    public function in(In $in): string
+    {
+        return 'in';
+    }
+
+    public function isNull(IsNull $isNull): string
+    {
+        return 'isNull';
+    }
+
+    public function not(Not $not): string
+    {
+        return 'not';
+    }
+
+    public function startsWith(StartsWith $startsWith): string
+    {
+        return 'startsWith';
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/RowGroupChunksSpy.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/RowGroupChunksSpy.php
new file mode 100644
index 0000000000..89e9e4b69d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/RowGroupChunksSpy.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Double;
+
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+/**
+ * Records the row group of each chunk read.
+ */
+final class RowGroupChunksSpy implements RowGroupChunks
+{
+    /**
+     * @var list<int>
+     */
+    public array $chunkReads = [];
+
+    public function __construct(
+        private readonly RowGroupChunks $chunks,
+    ) {}
+
+    public function chunk(int $rowGroup, FlatColumn $column): ColumnChunk
+    {
+        $this->chunkReads[] = $rowGroup;
+
+        return $this->chunks->chunk($rowGroup, $column);
+    }
+
+    public function columnOrder(FlatColumn $column): ColumnOrder
+    {
+        return $this->chunks->columnOrder($column);
+    }
+
+    public function rowCounts(): array
+    {
+        return $this->chunks->rowCounts();
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyFooter.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyFooter.php
new file mode 100644
index 0000000000..7d3e8402df
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyFooter.php
@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Double;
+
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\Footer;
+use Flow\Parquet\ParquetFile\Metadata;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\RowGroup;
+use Flow\Parquet\ParquetFile\RowGroupChunks;
+use Flow\Parquet\ParquetFile\RowGroups;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+/**
+ * Answers from in-memory metadata, records every rowGroupChunks() call.
+ */
+final class SpyFooter implements Footer
+{
+    /**
+     * @var list<list<FlatColumn>>
+     */
+    public array $rowGroupChunkReads = [];
+
+    /**
+     * @param list<RowGroup> $rowGroups
+     * @param list<ColumnOrder> $columnOrders one per leaf of the schema, empty for a file without column_orders
+     */
+    public function __construct(
+        private readonly Schema $schema,
+        private readonly int $rows = 0,
+        private readonly array $rowGroups = [],
+        private readonly array $columnOrders = [],
+    ) {}
+
+    public function metadata(): Metadata
+    {
+        return new Metadata($this->schema, new RowGroups($this->rowGroups), $this->rows, 1, null, $this->columnOrders);
+    }
+
+    public function rowGroupChunks(array $columns): RowGroupChunks
+    {
+        $this->rowGroupChunkReads[] = $columns;
+
+        return new MetadataRowGroupChunks($this->metadata());
+    }
+
+    public function rowsNumber(): int
+    {
+        return $this->rows;
+    }
+
+    public function schema(): Schema
+    {
+        return $this->schema;
+    }
+
+    public function totalByteSize(): int
+    {
+        return 0;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyParquetFileReader.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyParquetFileReader.php
index 4e8282f569..f00a6f1d58 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyParquetFileReader.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Double/SpyParquetFileReader.php
@@ -4,21 +4,24 @@
 
 namespace Flow\Parquet\Tests\Double;
 
-use Flow\Parquet\ParquetFile\Metadata;
-use Flow\Parquet\ParquetFile\RowGroups;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFileReader;
+use Flow\Parquet\Reader\ReadPlan;
 use Generator;
 
 /**
- * Answers from a schema, records close() and every readColumns() call.
+ * Answers from a SpyFooter, records close(), every readColumns() call and the chunks read.
  */
 final class SpyParquetFileReader implements ParquetFileReader
 {
+    public int $chunksRead = 0;
+
     public int $closes = 0;
 
+    public readonly SpyFooter $footer;
+
     /**
-     * @var list<array{list<string>, int, ?int, ?int}>
+     * @var list<array{list<string>, int, ReadPlan}>
      */
     public array $reads = [];
 
@@ -26,39 +29,31 @@ final class SpyParquetFileReader implements ParquetFileReader
      * @param list<array<string, list<mixed>>> $chunks
      */
     public function __construct(
-        private readonly Schema $schema,
+        Schema $schema,
         private readonly array $chunks = [],
-    ) {}
+        int $rows = 0,
+    ) {
+        $this->footer = new SpyFooter($schema, $rows);
+    }
 
     public function close(): void
     {
         $this->closes++;
     }
 
-    public function metadata(): Metadata
+    public function footer(): SpyFooter
     {
-        return new Metadata($this->schema, new RowGroups([]), 0, 1, null);
+        return $this->footer;
     }
 
-    public function readColumns(array $columns, int $batchSize, ?int $limit, ?int $offset): Generator
+    public function readColumns(array $columns, int $batchSize, ReadPlan $plan): Generator
     {
-        $this->reads[] = [$columns, $batchSize, $limit, $offset];
+        $this->reads[] = [$columns, $batchSize, $plan];
 
-        yield from $this->chunks;
-    }
+        foreach ($this->chunks as $chunk) {
+            $this->chunksRead++;
 
-    public function rowsNumber(): int
-    {
-        return 0;
-    }
-
-    public function schema(): Schema
-    {
-        return $this->schema;
-    }
-
-    public function totalByteSize(): int
-    {
-        return 0;
+            yield $chunk;
+        }
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Binary/BinaryReaderWriterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Binary/BinaryReaderWriterTest.php
index 772963c1bb..1fa342951e 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Binary/BinaryReaderWriterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Binary/BinaryReaderWriterTest.php
@@ -7,7 +7,6 @@
 use Flow\Parquet\Binary\ByteOrder;
 use Flow\Parquet\BinaryReader\BinaryBufferReader;
 use Flow\Parquet\BinaryWriter\BinaryBufferWriter;
-use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
@@ -106,22 +105,23 @@ public function test_writing_and_reading_big_integers_with_functions(): void
     #[DataProvider('decimalProvider')]
     public function test_writing_and_reading_decimals_with_functions(array $decimals, int $precision, int $scale): void
     {
-        $byteLength = (int) FlatColumn::decimal('decimal', $precision, $scale)->typeLength();
-
         $buffer = '';
         $writer = new BinaryBufferWriter($buffer);
+        $lengths = [];
 
         // @mago-ignore analysis:mixed-assignment
         foreach ($decimals as $decimal) {
             static::assertIsFloat($decimal);
-            $writer->append(encode_decimal($decimal, $precision, $scale, $byteLength));
+            $bytes = encode_decimal($decimal, $precision, $scale, null);
+            $lengths[] = strlen($bytes);
+            $writer->append($bytes);
         }
 
         $reader = new BinaryBufferReader($buffer);
         $decoded = [];
 
-        foreach ($decimals as $_ignored) {
-            $decoded[] = decode_decimal($reader->readBytes($byteLength), $scale);
+        foreach ($lengths as $length) {
+            $decoded[] = decode_decimal($reader->readBytes($length), $scale);
         }
 
         static::assertSame($decimals, $decoded);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/BloomFilter/BloomFilterReaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/BloomFilter/BloomFilterReaderTest.php
new file mode 100644
index 0000000000..1dbcd6a823
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/BloomFilter/BloomFilterReaderTest.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\BloomFilter;
+
+use Flow\Parquet\BloomFilter\BloomFilterReader;
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\FilterRows;
+use PHPUnit\Framework\TestCase;
+
+use function array_slice;
+use function Flow\Filesystem\DSL\native_local_filesystem;
+use function Flow\Filesystem\DSL\path;
+
+final class BloomFilterReaderTest extends TestCase
+{
+    public function test_every_value_duckdb_wrote_is_in_its_row_group_filter(): void
+    {
+        $fixture = __DIR__ . '/../Engine/Fixtures/Filters/bloom_duckdb.parquet';
+        $metadata = Reader::php()->read($fixture)->metadata();
+        $reader = new BloomFilterReader(native_local_filesystem()->readFrom(path($fixture)));
+        $rows = FilterRows::bloomRows(FilterRows::DUCKDB_BLOOM_ROWS);
+        $first = 0;
+        $missing = [];
+
+        foreach ($metadata->rowGroups()->all() as $rowGroup) {
+            foreach ($rowGroup->columnChunks() as $chunk) {
+                $column = $metadata->schema()->getFlat($chunk->flatPath());
+                $bloomFilter = $reader->read($chunk);
+
+                static::assertNotNull($bloomFilter);
+
+                foreach (array_slice($rows, $first, $rowGroup->rowsCount()) as $row) {
+                    if (!$bloomFilter->check((new BloomHash())->of($column, $row[$column->name()]))) {
+                        $missing[] = $row[$column->name()];
+                    }
+                }
+            }
+
+            $first += $rowGroup->rowsCount();
+        }
+
+        static::assertSame(FilterRows::DUCKDB_BLOOM_ROWS, $first);
+        static::assertSame([], $missing);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/CrossEngineTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/CrossEngineTest.php
index 621e61217e..7d6b3d6290 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/CrossEngineTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/CrossEngineTest.php
@@ -15,6 +15,7 @@
 use Flow\Parquet\ParquetFile\Schema\Repetition;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Context\TestParquetFile;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
 use Flow\Parquet\Writer;
 use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\TestCase;
@@ -63,8 +64,7 @@ public function test_arrow_write_arrow_read_roundtrip(): void
             $engine->openForRead($readStream)->readColumns(
                 ['id', 'label', 'big_number'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
@@ -156,8 +156,7 @@ public function test_php_write_arrow_read(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'name', 'value'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/FilterParityTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/FilterParityTest.php
new file mode 100644
index 0000000000..d5a8bea872
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/FilterParityTest.php
@@ -0,0 +1,640 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\Engine;
+
+use Closure;
+use DateTimeImmutable;
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+use Flow\Parquet\Query;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+use Flow\Parquet\Tests\Context\FilePlan;
+use Flow\Parquet\Tests\Context\FilterExpectations;
+use Flow\Parquet\Tests\Context\FilterRows;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\ParquetEngineMother;
+use Flow\Parquet\Writer;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+use function array_diff;
+use function array_filter;
+use function array_map;
+use function array_slice;
+use function array_values;
+use function extension_loaded;
+use function Flow\Parquet\DSL\parquet_column;
+use function is_float;
+use function is_int;
+use function iterator_to_array;
+use function range;
+use function serialize;
+
+#[Group('native-extension')]
+final class FilterParityTest extends TestCase
+{
+    /**
+     * Each filter, the raw rows a plan skips first, the row groups of 10 rows FilterRows keeps and the ids of the rows
+     * matching it, worked out from the data FilterRows writes.
+     *
+     * @return Generator<string, array{Filter, int, list<int>, list<int>}>
+     */
+    public static function filters(): Generator
+    {
+        yield 'equal' => [parquet_column('id')->equals(7), 0, [0], [7]];
+        yield 'in' => [parquet_column('id')->in([3, 33]), 0, [0, 3], [3, 33]];
+        yield 'starts with' => [
+            parquet_column('label')->startsWith('10'),
+            0,
+            [1, 2, 3],
+            [...range(10, 29), 31, 32, 34, 35, 37, 38],
+        ];
+        yield 'struct leaf' => [parquet_column('address.city')->equals('c2'), 0, [2], range(20, 29)];
+        yield 'absent column is null' => [parquet_column('missing')->isNull(), 0, [0, 1, 2, 3], range(0, 39)];
+        yield 'is null on a column holding nulls' => [
+            parquet_column('maybe')->isNull(),
+            0,
+            [0, 1],
+            [...range(0, 9), 11, 13, 15, 17, 19],
+        ];
+        yield 'is not null on a column holding nulls' => [
+            parquet_column('maybe')->isNotNull(),
+            0,
+            [1, 2, 3],
+            [10, 12, 14, 16, 18, ...range(20, 39)],
+        ];
+        yield 'any' => [
+            parquet_column('id')->equals(1)->or(parquet_column('label')->equals('100')),
+            0,
+            [0, 2, 3],
+            [1, ...range(20, 29), 32, 35, 38],
+        ];
+        yield 'offset inside a kept group, then a pruned group' => [
+            parquet_column('id')->in([3, 33]),
+            5,
+            [0, 3],
+            [3, 33],
+        ];
+    }
+
+    /**
+     * @return Generator<string, array{string, Filter, int, list<int>}>
+     */
+    public static function fixtures_and_filters(): Generator
+    {
+        foreach (['row_groups_php', 'row_groups_arrow'] as $fixture) {
+            foreach (self::filters() as $name => [$filter, $offset, $kept]) {
+                yield $fixture . ': ' . $name => [$fixture, $filter, $offset, $kept];
+            }
+        }
+    }
+
+    /**
+     * @return Generator<string, array{string, Filter, list<int>}>
+     */
+    public static function fixture_filters(): Generator
+    {
+        foreach (['row_groups_php', 'row_groups_arrow'] as $fixture) {
+            foreach (self::filters() as $name => [$filter, , , $ids]) {
+                yield $fixture . ': ' . $name => [$fixture, $filter, $ids];
+            }
+        }
+    }
+
+    /**
+     * @return Generator<string, array{Filter, int}>
+     */
+    public static function duckdb_filters(): Generator
+    {
+        foreach (self::filters() as $name => [$filter, $offset]) {
+            yield $name => [$filter, $offset];
+        }
+    }
+
+    /**
+     * arrow-rs reads the file's day (INT32 DATE) as Date64 milliseconds and its ts (plain INT64) as Timestamp(Second),
+     * as the file's arrow schema hints; seconds (TIMESTAMP(MILLIS) hinted Timestamp(Second), as pyarrow writes it) it
+     * reads in milliseconds.
+     *
+     * @return Generator<string, array{Filter, list<int>}>
+     */
+    public static function hinted_filters(): Generator
+    {
+        yield 'date64 at least' => [
+            parquet_column('day')->greaterThanOrEqual(new DateTimeImmutable('2024-01-05 UTC')),
+            [5, 6, 7, 8, 9],
+        ];
+        yield 'date64 not in' => [
+            parquet_column('day')->in([
+                new DateTimeImmutable('2024-01-08 UTC'),
+                new DateTimeImmutable('2024-01-02 UTC'),
+            ])->negate(),
+            [0, 2, 3, 5, 6, 8, 9],
+        ];
+        yield 'pyarrow seconds stored as milliseconds' => [
+            parquet_column('seconds')->lessThanOrEqual(new DateTimeImmutable('2024-01-01 04:00:00 UTC'))->negate(),
+            [5, 6, 7, 8, 9],
+        ];
+        yield 'seconds below' => [parquet_column('ts')->lessThan(1_704_067_200 + (5 * 3600)), [0, 1, 2, 3, 4]];
+        yield 'seconds null or above' => [
+            parquet_column('ts')->isNull()->or(parquet_column('ts')->greaterThan(1_704_067_200 + (7 * 3600))),
+            [6, 8, 9],
+        ];
+    }
+
+    /**
+     * Row-level cases: nulls, a struct leaf under null structs, a decimal, a timestamp, an absent column, and conjuncts
+     * bound beside one that is not. NaN, -0.0 and each operator's negation are RowEvaluatorTest's.
+     *
+     * @return Generator<string, array{string, Filter}>
+     */
+    public static function row_filters(): Generator
+    {
+        $filters = [
+            'nulls under not and any' => parquet_column('maybe')
+                ->lessThan(14)
+                ->or(parquet_column('maybe')->isNull())
+                ->negate(),
+            'struct leaf under null structs' => parquet_column('address.city')->equals('c3')->negate(),
+            'decimal' => parquet_column('amount')->greaterThan(12.25)->negate(),
+            'timestamp' => parquet_column('ts')->greaterThan(new DateTimeImmutable('2024-01-02 09:00:00.123456 UTC')),
+            'absent column' => parquet_column('missing')->equals(1)->negate(),
+            'bound beside unbound' => new All(
+                parquet_column('id')->lessThan(25),
+                parquet_column('big')->lessThan(1.0e18),
+                parquet_column('score')->lessThan(5.0)->negate(),
+            ),
+        ];
+
+        foreach (['row_groups_php', 'row_groups_arrow'] as $fixture) {
+            foreach ($filters as $name => $filter) {
+                yield $fixture . ': ' . $name => [$fixture, $filter];
+            }
+        }
+    }
+
+    protected function setUp(): void
+    {
+        if (!extension_loaded('arrow')) {
+            self::markTestSkipped('arrow is not loaded');
+        }
+    }
+
+    #[DataProvider('row_filters')]
+    public function test_both_engines_read_exactly_the_rows_the_row_filter_keeps(string $fixture, Filter $filter): void
+    {
+        $all = FilterRows::file($fixture, PhpParquetEngine::class);
+        $columns = ['id', 'score', 'maybe', 'address'];
+        $rows = [];
+
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $file = FilterRows::file($fixture, $engine);
+            $plan = FilePlan::of($file, $filter);
+            $rowFilter = $plan->rowFilter ?? static::fail('The filter has no bound conjunct');
+            $rows[$engine] = FilePlan::rows($file, $columns, $plan);
+
+            static::assertSame(
+                FilterExpectations::matchingIds($all->values(), $rowFilter->filter(), $all->schema()),
+                FilterExpectations::ids($rows[$engine]),
+            );
+            static::assertSame(
+                [],
+                array_diff(
+                    FilterExpectations::matchingIds($all->values(), $filter, $all->schema()),
+                    FilterExpectations::ids($rows[$engine]),
+                ),
+            );
+        }
+
+        // serialized: NaN equals itself and -0.0 differs from +0.0
+        static::assertSame(serialize($rows[PhpParquetEngine::class]), serialize($rows[RustParquetEngine::class]));
+    }
+
+    /**
+     * @param list<int> $ids
+     */
+    #[DataProvider('hinted_filters')]
+    public function test_both_engines_filter_the_columns_an_arrow_schema_hints_alike(Filter $filter, array $ids): void
+    {
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $file = FilterRows::file('row_filter_hints_arrow', $engine);
+
+            static::assertSame(
+                $ids,
+                FilterExpectations::ids(FilePlan::rows($file, ['id'], FilePlan::of($file, $filter))),
+            );
+        }
+    }
+
+    public function test_an_unbound_conjunct_is_left_out_of_the_row_filter_and_read_as_a_superset(): void
+    {
+        $bound = parquet_column('id')->lessThan(25);
+        // a float beyond 2^53 has no exact pre-image on UINT_64: the conjunct is unbound, FilterEvaluator still answers it
+        $filter = $bound->and(parquet_column('big')->lessThan(1.0e18));
+
+        foreach (['row_groups_php', 'row_groups_arrow'] as $fixture) {
+            foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+                $file = FilterRows::file($fixture, $engine);
+                $plan = FilePlan::of($file, $filter);
+
+                static::assertSame($bound, $plan->rowFilter?->filter());
+                static::assertSame(range(0, 24), FilterExpectations::ids(FilePlan::rows($file, ['id'], $plan)));
+                static::assertSame(range(0, 19), FilterExpectations::ids($file->values(new Query(['id'], $filter))));
+            }
+        }
+    }
+
+    public function test_both_engines_filter_nanosecond_timestamps_by_the_microsecond_they_decode_to(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('id'), FlatColumnMother::timestamp(TimeUnit::NANOSECONDS));
+        $rows = array_map(
+            static fn(int $id): array => [
+                'id' => $id,
+                'ts' => (new DateTimeImmutable('2024-01-01 00:00:00.000001 UTC'))->modify('+' . $id . ' microseconds'),
+            ],
+            range(0, 9),
+        );
+        $filter = parquet_column('ts')->equals(
+            new DateTimeImmutable('2024-01-01 00:00:00.000003 UTC'),
+        )->or(parquet_column('ts')->greaterThan(new DateTimeImmutable('2024-01-01 00:00:00.000008 UTC')));
+
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $writer) {
+            $bytes = MemoryParquetFile::written(
+                new Writer(engine: ParquetEngineMother::create($writer)),
+                $schema,
+                $rows,
+            );
+
+            foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+                $file = MemoryParquetFile::read(new Reader(engine: ParquetEngineMother::create($engine)), $bytes);
+
+                static::assertSame(
+                    [2, 8, 9],
+                    FilterExpectations::ids(FilePlan::rows($file, ['id'], FilePlan::of($file, $filter))),
+                );
+            }
+        }
+    }
+
+    /**
+     * @param list<int> $kept
+     */
+    #[DataProvider('fixtures_and_filters')]
+    public function test_both_engines_plan_one_selection_that_keeps_every_matching_row(
+        string $fixture,
+        Filter $filter,
+        int $offset,
+        array $kept,
+    ): void {
+        $all = FilterRows::file($fixture, PhpParquetEngine::class);
+        $matching = FilterExpectations::matchingGroups(
+            $all->values(),
+            $filter,
+            $all->schema(),
+            FilterRows::ROWS_PER_GROUP,
+            $offset,
+        );
+        $plans = [];
+
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $plans[$engine] = FilePlan::of(FilterRows::file($fixture, $engine), $filter, $offset);
+        }
+
+        static::assertEquals($plans[PhpParquetEngine::class]->selection, $plans[RustParquetEngine::class]->selection);
+        static::assertEquals($plans[PhpParquetEngine::class]->matched, $plans[RustParquetEngine::class]->matched);
+        static::assertSame($kept, FilterExpectations::keptGroups(
+            $plans[PhpParquetEngine::class]->selection,
+            FilterRows::ROWS_PER_GROUP,
+        ));
+        static::assertSame([], array_diff($matching, $kept));
+    }
+
+    /**
+     * @param list<int> $ids
+     */
+    #[DataProvider('fixture_filters')]
+    public function test_both_engines_read_exactly_the_matching_rows(string $fixture, Filter $filter, array $ids): void
+    {
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            static::assertSame(
+                $ids,
+                FilterExpectations::ids(FilterRows::file($fixture, $engine)->values(new Query(['id'], $filter))),
+            );
+        }
+    }
+
+    public function test_offset_and_limit_count_the_matching_rows(): void
+    {
+        $filter = parquet_column('id')->in([3, 7, 33, 35, 38]);
+
+        foreach (['row_groups_php', 'row_groups_arrow'] as $fixture) {
+            foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+                static::assertSame(
+                    [7, 33],
+                    FilterExpectations::ids(FilterRows::file($fixture, $engine)->values(
+                        new Query(['id'], $filter, offset: 1, limit: 2),
+                    )),
+                );
+            }
+        }
+    }
+
+    #[DataProvider('duckdb_filters')]
+    public function test_both_engines_keep_every_duckdb_row_group_holding_a_match(Filter $filter, int $offset): void
+    {
+        $plans = [];
+
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $plans[$engine] = FilePlan::of(FilterRows::file('row_groups_duckdb', $engine), $filter, $offset);
+        }
+
+        $matching = FilterExpectations::matchingGroups(
+            FilterRows::rows(FilterRows::DUCKDB_ROWS_PER_GROUP),
+            $filter,
+            FilterRows::schema(),
+            FilterRows::DUCKDB_ROWS_PER_GROUP,
+            $offset,
+        );
+
+        static::assertEquals($plans[PhpParquetEngine::class]->selection, $plans[RustParquetEngine::class]->selection);
+        static::assertEquals($plans[PhpParquetEngine::class]->matched, $plans[RustParquetEngine::class]->matched);
+        static::assertSame(
+            [],
+            array_diff($matching, FilterExpectations::keptGroups(
+                $plans[PhpParquetEngine::class]->selection,
+                FilterRows::DUCKDB_ROWS_PER_GROUP,
+            )),
+        );
+    }
+
+    public function test_both_engines_read_exactly_the_matching_duckdb_rows_from_the_kept_group(): void
+    {
+        $filter = parquet_column('id')->lessThan(100);
+
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $file = FilterRows::file('row_groups_duckdb', $engine);
+            static::assertSame(
+                [0],
+                FilterExpectations::keptGroups(
+                    FilePlan::of($file, $filter)->selection,
+                    FilterRows::DUCKDB_ROWS_PER_GROUP,
+                ),
+            );
+            static::assertSame(range(0, 99), FilterExpectations::ids($file->values(new Query(['id'], $filter))));
+        }
+    }
+
+    public function test_both_engines_keep_every_row_group_of_a_file_without_column_orders(): void
+    {
+        $fixture = __DIR__ . '/../IO/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet';
+
+        foreach ([parquet_column('id')->equals(1), parquet_column('name')->equals('name-1')] as $filter) {
+            foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+                $file = (new Reader(engine: ParquetEngineMother::create($engine)))->read($fixture);
+                static::assertEquals(RowSelection::all(5000), FilePlan::of($file, $filter)->selection);
+                static::assertSame([1], FilterExpectations::ids($file->values(new Query(['id'], $filter))));
+            }
+        }
+    }
+
+    public function test_an_offset_from_inside_a_kept_group_reads_its_rest_and_skips_the_pruned_groups(): void
+    {
+        foreach (['row_groups_php', 'row_groups_arrow'] as $fixture) {
+            foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+                static::assertEquals(
+                    new RowSelection(
+                        new RowSelector(5, true),
+                        new RowSelector(5, false),
+                        new RowSelector(20, true),
+                        new RowSelector(10, false),
+                    ),
+                    FilePlan::of(FilterRows::file($fixture, $engine), parquet_column('id')->in([3, 33]), 5)->selection,
+                );
+            }
+        }
+    }
+
+    /**
+     * Pages of the parquet-mr file start at other rows per column: int64 at 0, 200, 428, 628, 828; float at 0, 300,
+     * 628, 928. Each filter keeps pages the other column's boundaries cut through.
+     *
+     * @return Generator<string, array{Filter, RowSelection, Closure(array<string, mixed>): bool}>
+     */
+    public static function parquet_mr_page_filters(): Generator
+    {
+        yield 'int64 range' => [
+            parquet_column('int64_column')->lessThan(300),
+            new RowSelection(new RowSelector(428, false), new RowSelector(572, true)),
+            static fn(array $row): bool => is_int($row['int64_column']) && $row['int64_column'] < 300,
+        ];
+        yield 'float range' => [
+            parquet_column('float_column')->lessThan(400.0),
+            new RowSelection(new RowSelector(628, false), new RowSelector(372, true)),
+            static fn(array $row): bool => is_float($row['float_column']) && $row['float_column'] < 400.0,
+        ];
+    }
+
+    /**
+     * Even ids only, so every odd id lies inside a group's min/max: only a bloom filter drops its group.
+     *
+     * @return Generator<string, array{string, Filter, RowSelection, list<int>}>
+     */
+    public static function bloom_filters(): Generator
+    {
+        foreach (['bloom_php', 'bloom_arrow'] as $fixture) {
+            yield $fixture . ': absent id' => [$fixture, parquet_column('id')->equals(33), RowSelection::none(40), []];
+            yield $fixture . ': in, present and absent' => [
+                $fixture,
+                parquet_column('id')->in([24, 33]),
+                new RowSelection(new RowSelector(10, true), new RowSelector(10, false), new RowSelector(20, true)),
+                [24],
+            ];
+            yield $fixture . ': present key' => [
+                $fixture,
+                parquet_column('key')->equals('k50'),
+                new RowSelection(new RowSelector(20, true), new RowSelector(10, false), new RowSelector(10, true)),
+                [50],
+            ];
+        }
+
+        yield 'bloom_duckdb: absent id' => [
+            'bloom_duckdb',
+            parquet_column('id')->equals(4_001),
+            RowSelection::none(FilterRows::DUCKDB_BLOOM_ROWS),
+            [],
+        ];
+        yield 'bloom_duckdb: in, present and absent' => [
+            'bloom_duckdb',
+            parquet_column('id')->in([4_000, 4_001]),
+            new RowSelection(new RowSelector(2048, false), new RowSelector(6144, true)),
+            [4_000],
+        ];
+        yield 'bloom_duckdb: present key' => [
+            'bloom_duckdb',
+            parquet_column('key')->equals('k10000'),
+            new RowSelection(new RowSelector(4096, true), new RowSelector(2048, false), new RowSelector(2048, true)),
+            [10_000],
+        ];
+    }
+
+    /**
+     * @return Generator<string, array{string, Filter, RowSelection, RowSelection, list<int>}>
+     */
+    public static function page_filters(): Generator
+    {
+        foreach (['pages_php', 'pages_arrow'] as $fixture) {
+            yield $fixture . ': string prefix' => [
+                $fixture,
+                parquet_column('label')->startsWith('10'),
+                new RowSelection(new RowSelector(10, true), new RowSelector(30, false)),
+                new RowSelection(new RowSelector(10, true), new RowSelector(20, false), new RowSelector(10, true)),
+                [...range(10, 29), 31, 32, 34, 35, 37, 38],
+            ];
+            yield $fixture . ': not less than on NaN' => [
+                $fixture,
+                parquet_column('score')->lessThan(100.0)->negate(),
+                new RowSelection(
+                    new RowSelector(10, true),
+                    new RowSelector(5, false),
+                    new RowSelector(5, true),
+                    new RowSelector(10, false),
+                    new RowSelector(10, true),
+                ),
+                new RowSelection(new RowSelector(20, true), new RowSelector(10, false), new RowSelector(10, true)),
+                [11, ...range(20, 29)],
+            ];
+        }
+
+        $nullable = [...range(0, 9), 11, 13, 15, 17, 19];
+        $defined = [10, 12, 14, 16, 18, ...range(20, 39)];
+
+        yield 'pages_php: is null on a column holding nulls' => [
+            'pages_php',
+            parquet_column('maybe')->isNull(),
+            new RowSelection(new RowSelector(20, false), new RowSelector(20, true)),
+            new RowSelection(new RowSelector(10, false), new RowSelector(30, true)),
+            $nullable,
+        ];
+        yield 'pages_php: is not null on a column holding nulls' => [
+            'pages_php',
+            parquet_column('maybe')->isNotNull(),
+            new RowSelection(new RowSelector(10, true), new RowSelector(30, false)),
+            new RowSelection(new RowSelector(20, true), new RowSelector(20, false)),
+            $defined,
+        ];
+        // the arrow writer's pages break at other rows: none holds only nulls
+        yield 'pages_arrow: is null on a column holding nulls' => [
+            'pages_arrow',
+            parquet_column('maybe')->isNull(),
+            new RowSelection(new RowSelector(20, false), new RowSelector(20, true)),
+            RowSelection::none(40),
+            $nullable,
+        ];
+        yield 'pages_arrow: is not null on a column holding nulls' => [
+            'pages_arrow',
+            parquet_column('maybe')->isNotNull(),
+            RowSelection::all(40),
+            new RowSelection(new RowSelector(20, true), new RowSelector(20, false)),
+            $defined,
+        ];
+    }
+
+    /**
+     * @param Closure(array<string, mixed>): bool $matches
+     */
+    #[DataProvider('parquet_mr_page_filters')]
+    public function test_both_engines_page_prune_a_file_whose_columns_break_pages_at_other_rows(
+        Filter $filter,
+        RowSelection $selection,
+        Closure $matches,
+    ): void {
+        $fixture = __DIR__ . '/../IO/Fixtures/delta_binary_acked_encoded_integers.parquet';
+        $columns = ['int32_column', 'int64_column', 'float_column'];
+        $all = iterator_to_array(Reader::php()->read($fixture)->values(), false);
+        $rows = [];
+
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $file = (new Reader(engine: ParquetEngineMother::create($engine)))->read($fixture);
+            $plan = FilePlan::of($file, $filter);
+
+            static::assertEquals($selection, $plan->selection);
+            $rows[$engine] = FilePlan::rows($file, $columns, $plan);
+            static::assertSame(
+                array_values(array_filter($all, $matches)),
+                iterator_to_array($file->values(new Query($columns, $filter)), false),
+            );
+        }
+
+        static::assertSame($rows[PhpParquetEngine::class], $rows[RustParquetEngine::class]);
+        static::assertSame(array_values(array_filter($all, $matches)), $rows[PhpParquetEngine::class]);
+    }
+
+    /**
+     * @param list<int> $ids
+     */
+    #[DataProvider('bloom_filters')]
+    public function test_both_engines_skip_the_row_groups_whose_bloom_filters_lack_every_literal(
+        string $fixture,
+        Filter $filter,
+        RowSelection $selection,
+        array $ids,
+    ): void {
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $file = FilterRows::file($fixture, $engine);
+
+            static::assertEquals($selection, FilePlan::of($file, $filter)->selection);
+            static::assertSame($ids, FilterExpectations::ids($file->values(new Query(['id'], $filter))));
+        }
+    }
+
+    /**
+     * @param list<int> $ids
+     */
+    #[DataProvider('page_filters')]
+    public function test_both_engines_select_and_match_the_same_pages(
+        string $fixture,
+        Filter $filter,
+        RowSelection $selection,
+        RowSelection $matched,
+        array $ids,
+    ): void {
+        foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+            $file = FilterRows::file($fixture, $engine);
+            $plan = FilePlan::of($file, $filter);
+
+            static::assertEquals($selection, $plan->selection);
+            static::assertEquals($matched, $plan->matched);
+            static::assertSame($ids, FilterExpectations::ids($file->values(new Query(['id'], $filter))));
+        }
+    }
+
+    public function test_both_engines_trim_a_list_inside_a_struct_to_the_selected_rows_of_a_page(): void
+    {
+        $expected = array_map(
+            static fn(array $row): array => ['id' => $row['id'], 'address' => $row['address']],
+            array_slice(FilterRows::pageRows(), 12),
+        );
+
+        foreach (['pages_php', 'pages_arrow'] as $fixture) {
+            foreach ([PhpParquetEngine::class, RustParquetEngine::class] as $engine) {
+                $file = FilterRows::file($fixture, $engine);
+                $plan = FilePlan::of($file, parquet_column('id')->greaterThanOrEqual(12), 12);
+
+                static::assertEquals(RowSelection::window(40, 12), $plan->selection);
+                static::assertEquals($expected, FilePlan::rows($file, ['id', 'address'], $plan));
+            }
+        }
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/bloom_duckdb.parquet b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/bloom_duckdb.parquet
new file mode 100644
index 0000000000..00af4e4afb
Binary files /dev/null and b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/bloom_duckdb.parquet differ
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/row_filter_hints_arrow.parquet b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/row_filter_hints_arrow.parquet
new file mode 100644
index 0000000000..8a6a6d4476
Binary files /dev/null and b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/row_filter_hints_arrow.parquet differ
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/row_groups_duckdb.parquet b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/row_groups_duckdb.parquet
new file mode 100644
index 0000000000..14119a05f3
Binary files /dev/null and b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/Filters/row_groups_duckdb.parquet differ
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/uint64_duckdb.parquet b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/uint64_duckdb.parquet
new file mode 100644
index 0000000000..a4a24b0237
Binary files /dev/null and b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/Fixtures/uint64_duckdb.parquet differ
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/ReadColumnsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/ReadColumnsTest.php
index 2d0048446f..0f26dec508 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/ReadColumnsTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/ReadColumnsTest.php
@@ -14,6 +14,7 @@
 use Flow\Parquet\Tests\Context\TestParquetFile;
 use Flow\Parquet\Tests\Integration\IO\ParquetIntegrationTestCase;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
 use Flow\Parquet\Writer;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -69,8 +70,7 @@ public function test_chunks_follow_batch_size_limit_and_offset(
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'tags'],
                 $batchSize,
-                $limit,
-                $offset,
+                ReadPlanMother::window(5, $offset ?? 0, $limit),
             ),
             false,
         );
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RowGroupChunksParityTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RowGroupChunksParityTest.php
new file mode 100644
index 0000000000..5f6f7e9801
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RowGroupChunksParityTest.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\Engine;
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Filesystem\Stream\NativeLocalSourceStream;
+use Flow\Parquet\Engine\RustParquetFileReader;
+use Flow\Parquet\Filter\Evaluation\RowGroupZoneMaps;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\FilterRows;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function array_keys;
+use function array_values;
+use function extension_loaded;
+use function Flow\Filesystem\DSL\path_real;
+use function var_export;
+
+#[Group('native-extension')]
+final class RowGroupChunksParityTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        if (!extension_loaded('arrow')) {
+            self::markTestSkipped('arrow is not loaded');
+        }
+    }
+
+    #[TestWith(['row_groups_php'])]
+    #[TestWith(['row_groups_arrow'])]
+    #[TestWith(['row_groups_duckdb'])]
+    #[TestWith(['../../../IO/Fixtures/pagination_row_group_1kb_5k_rows.snappy'])]
+    #[TestWith(['../../../IO/Fixtures/EdgeCases/datapage_v2.snappy'])]
+    public function test_the_arrow_footer_slices_give_the_zone_maps_of_the_php_footer(string $fixture): void
+    {
+        $bytes = FilterRows::bytes($fixture);
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $columns = array_values($file->schema()->columnsFlat());
+        $php = $file->reader()->footer()->rowGroupChunks($columns);
+        $rust = (new RustParquetFileReader(new MemorySourceStream($bytes)))
+            ->footer()
+            ->rowGroupChunks($columns);
+
+        static::assertSame($php->rowCounts(), $rust->rowCounts());
+
+        foreach (array_keys($php->rowCounts()) as $group) {
+            foreach ($columns as $column) {
+                static::assertSame($php->columnOrder($column), $rust->columnOrder($column));
+                // var_export: a NaN bound never equals itself
+                static::assertSame(
+                    var_export((new RowGroupZoneMaps($php, $group))->zone($column), true),
+                    var_export((new RowGroupZoneMaps($rust, $group))->zone($column), true),
+                );
+            }
+        }
+    }
+
+    public function test_deprecated_bounds_of_a_legacy_file_stay_untrusted_through_the_arrow_footer(): void
+    {
+        $fixture = __DIR__ . '/../IO/Fixtures/EdgeCases/datapage_v2.snappy.parquet';
+        $columns = array_values(Reader::php()->read($fixture)->schema()->columnsFlat());
+        $chunks = (new RustParquetFileReader(NativeLocalSourceStream::open(path_real($fixture))))
+            ->footer()
+            ->rowGroupChunks($columns);
+
+        foreach ($columns as $column) {
+            static::assertNotNull($chunks->chunk(0, $column)->statistics()?->min($column));
+            static::assertNull((new RowGroupZoneMaps($chunks, 0))->zone($column)?->min);
+            static::assertNull((new RowGroupZoneMaps($chunks, 0))->zone($column)?->max);
+        }
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibParityTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibParityTest.php
index 5032b05caf..91078c851a 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibParityTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibParityTest.php
@@ -5,7 +5,6 @@
 namespace Flow\Parquet\Tests\Integration\Engine;
 
 use Flow\Parquet\Engine\RustParquetEngine;
-use Flow\Parquet\Exception\DataConversionException;
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\Reader;
@@ -111,21 +110,27 @@ public function test_an_interval_column_is_refused_naming_it_and_the_php_reader(
         ParquetRows::read((new Reader(engine: new RustParquetEngine()))->read($path), 100);
     }
 
-    public function test_a_uint64_above_php_int_max_is_refused_by_both_engines(): void
+    public function test_a_uint64_above_php_int_max_reads_as_the_same_decimal_string_on_both_engines(): void
     {
         $path = __DIR__ . '/../IO/Fixtures/EdgeCases/uint64_overflow.parquet';
 
-        try {
-            ParquetRows::read(Reader::php()->read($path), 100);
-            static::fail('PhpParquetEngine must refuse a UINT_64 above PHP_INT_MAX');
-        } catch (DataConversionException $exception) {
-            static::assertStringContainsString('holds a UINT_64 value above PHP_INT_MAX', $exception->getMessage());
-        }
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Parquet column "u64" row 0 holds a value out of the range arrow stores it in');
+        static::assertSame([['u64' => '18446744073709551615']], ParquetRows::read(Reader::php()->read($path), 100));
+        static::assertSame(
+            ParquetRows::read(Reader::php()->read($path), 100),
+            ParquetRows::read((new Reader(engine: new RustParquetEngine()))->read($path), 100),
+        );
+    }
 
-        ParquetRows::read((new Reader(engine: new RustParquetEngine()))->read($path), 100);
+    public function test_the_duckdb_uint64_fixture_reads_as_decimal_strings_on_both_engines(): void
+    {
+        $path = __DIR__ . '/Fixtures/uint64_duckdb.parquet';
+        $expected = [['col0' => '0'], ['col0' => '9223372036854775808'], ['col0' => '18446744073709551615']];
+
+        static::assertSame($expected, ParquetRows::read(Reader::php()->read($path), 10));
+        static::assertSame($expected, ParquetRows::read(
+            (new Reader(engine: new RustParquetEngine()))->read($path),
+            10,
+        ));
     }
 
     #[TestWith(['double_key', 'float'])]
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibRegressionTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibRegressionTest.php
index d080c07c5f..5dd0144e36 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibRegressionTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustLibRegressionTest.php
@@ -14,6 +14,7 @@
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Context\MemoryParquetFile;
 use Flow\Parquet\Tests\Context\ParquetRows;
@@ -52,12 +53,8 @@ public function test_an_offset_read_reads_only_the_footer_and_the_row_group_it_n
         }
 
         $stream = new ReadCountingSourceStream(NativeLocalSourceStream::open(path_real(self::PAGINATION)));
-        $rows = iterator_to_array(
-            (new Reader(engine: new RustParquetEngine()))
-                ->readStream($stream)
-                ->values([], 10, 4990),
-            false,
-        );
+        $file = (new Reader(engine: new RustParquetEngine()))->readStream($stream);
+        $rows = iterator_to_array($file->values(new Query(offset: 4990, limit: 10)), false);
 
         static::assertCount(10, $rows);
         static::assertLessThanOrEqual($footer + 8 + $group, $stream->bytes);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustParquetEngineReadTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustParquetEngineReadTest.php
index 3e90a088c4..ff648899db 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustParquetEngineReadTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/RustParquetEngineReadTest.php
@@ -14,6 +14,7 @@
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
 use Flow\Parquet\ParquetFile\Schema\Repetition;
 use Flow\Parquet\Tests\Context\TestParquetFile;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
 use Flow\Parquet\Writer;
 use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\TestCase;
@@ -63,8 +64,7 @@ public function test_read_flat_columns(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'name', 'active', 'score'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
@@ -99,8 +99,7 @@ public function test_read_nested_lists(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'tags'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
@@ -129,8 +128,7 @@ public function test_read_nested_maps(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'metadata'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
@@ -165,8 +163,7 @@ public function test_read_nested_structs(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'address'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
@@ -199,8 +196,7 @@ public function test_read_nested_uuid_as_canonical_strings(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['top_uuid', 'body', 'uuid_list'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(1),
             ),
             false,
         );
@@ -237,8 +233,7 @@ public function test_read_with_column_projection(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id', 'name'],
                 batchSize: 2,
-                limit: null,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData)),
             ),
             false,
         );
@@ -261,8 +256,7 @@ public function test_read_with_limit(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id'],
                 batchSize: 2,
-                limit: 5,
-                offset: null,
+                plan: ReadPlanMother::window(count($inputData), 0, 5),
             ),
             false,
         );
@@ -285,8 +279,7 @@ public function test_read_with_limit_and_offset(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id'],
                 batchSize: 2,
-                limit: 5,
-                offset: 10,
+                plan: ReadPlanMother::window(count($inputData), 10, 5),
             ),
             false,
         );
@@ -309,8 +302,7 @@ public function test_read_with_offset(): void
             $engine->openForRead(NativeLocalSourceStream::open(path_real($path)))->readColumns(
                 ['id'],
                 batchSize: 2,
-                limit: null,
-                offset: 96,
+                plan: ReadPlanMother::window(count($inputData), 96),
             ),
             false,
         );
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/SchemaParityTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/SchemaParityTest.php
new file mode 100644
index 0000000000..459f0aa0d2
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/SchemaParityTest.php
@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\Engine;
+
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType as C;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\LogicalType as L;
+use Flow\Parquet\ParquetFile\Schema\MapKey;
+use Flow\Parquet\ParquetFile\Schema\MapValue;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType as P;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\EveryType;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Mother\ParquetEngineMother;
+use Flow\Parquet\Writer;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function array_map;
+use function extension_loaded;
+
+#[Group('native-extension')]
+final class SchemaParityTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        if (!extension_loaded('arrow')) {
+            self::markTestSkipped('arrow is not loaded');
+        }
+    }
+
+    #[TestWith([PhpParquetEngine::class])]
+    #[TestWith([RustParquetEngine::class])]
+    public function test_every_type_is_written_with_one_physical_schema(string $engine): void
+    {
+        static::assertEquals(
+            [
+                ['boolean',                         P::BOOLEAN,              null, null,                null],
+                ['int32',                           P::INT32,                null, null,                null],
+                ['int64',                           P::INT64,                null, null,                null],
+                ['float',                           P::FLOAT,                null, null,                null],
+                ['double',                          P::DOUBLE,               null, null,                null],
+                ['string',                          P::BYTE_ARRAY,           null, C::UTF8,             L::string()],
+                ['json',                            P::BYTE_ARRAY,           null, C::JSON,             L::json()],
+                ['enum',                            P::BYTE_ARRAY,           null, C::ENUM,             L::enum()],
+                ['uuid',                            P::FIXED_LEN_BYTE_ARRAY, 16,   null,                L::uuid()],
+                ['date',                            P::INT32,                null, C::DATE,             L::date()],
+                ['datetime',                        P::INT64,                null, C::TIMESTAMP_MICROS, L::timestamp()],
+                ['time',                            P::INT64,                null, C::TIME_MICROS,      L::time()],
+                ['decimal',                         P::INT64,                null, C::DECIMAL,          L::decimal(
+                    2,
+                    10,
+                )],
+                ['decimal38',                       P::FIXED_LEN_BYTE_ARRAY, 16,   C::DECIMAL,          L::decimal(
+                    9,
+                    38,
+                )],
+                ['fixed4',                          P::FIXED_LEN_BYTE_ARRAY, 4,    null,                null],
+                ['list_int.list.element',           P::INT64,                null, null,                null],
+                ['list_datetime.list.element',      P::INT64,                null, C::TIMESTAMP_MICROS, L::timestamp()],
+                ['map_string_date.key_value.key',   P::BYTE_ARRAY,           null, C::UTF8,             L::string()],
+                ['map_string_date.key_value.value', P::INT32,                null, C::DATE,             L::date()],
+                ['struct.id',                       P::FIXED_LEN_BYTE_ARRAY, 16,   null,                L::uuid()],
+                ['struct.at',                       P::INT64,                null, C::TIME_MICROS,      L::time()],
+                ['struct.amount',                   P::INT64,                null, C::DECIMAL,          L::decimal(
+                    2,
+                    10,
+                )],
+            ],
+            array_map(
+                static fn(FlatColumn $column): array => [
+                    $column->flatPath(),
+                    $column->type(),
+                    $column->typeLength(),
+                    $column->convertedType(),
+                    $column->logicalType(),
+                ],
+                MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+                    new Writer(engine: ParquetEngineMother::create($engine)),
+                    EveryType::schema(),
+                    EveryType::rows(),
+                ))
+                    ->metadata()
+                    ->schema()
+                    ->columnsFlat(),
+            ),
+        );
+    }
+
+    #[TestWith([PhpParquetEngine::class])]
+    #[TestWith([RustParquetEngine::class])]
+    public function test_nested_enum_leaves_are_written_as_enum(string $engine): void
+    {
+        static::assertEquals(
+            [
+                ['list.list.element.colour',   C::ENUM, L::enum()],
+                ['list.list.element.name',     C::UTF8, L::string()],
+                ['map.key_value.key',          C::UTF8, L::string()],
+                ['map.key_value.value.colour', C::ENUM, L::enum()],
+                ['struct.colour',              C::ENUM, L::enum()],
+                ['struct.name',                C::UTF8, L::string()],
+            ],
+            array_map(
+                static fn(FlatColumn $column): array => [
+                    $column->flatPath(),
+                    $column->convertedType(),
+                    $column->logicalType(),
+                ],
+                MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+                    new Writer(engine: ParquetEngineMother::create($engine)),
+                    Schema::with(
+                        NestedColumn::list('list', ListElement::structure([
+                            FlatColumn::enum('colour'),
+                            FlatColumn::string('name'),
+                        ])),
+                        NestedColumn::map('map', MapKey::string(), MapValue::structure([FlatColumn::enum('colour')])),
+                        NestedColumn::struct('struct', [FlatColumn::enum('colour'), FlatColumn::string('name')]),
+                    ),
+                    [[
+                        'list' => [['colour' => 'RED', 'name' => 'a']],
+                        'map' => ['k' => ['colour' => 'GREEN']],
+                        'struct' => ['colour' => 'BLUE', 'name' => 'b'],
+                    ]],
+                ))
+                    ->metadata()
+                    ->schema()
+                    ->columnsFlat(),
+            ),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/StatisticsParityTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/StatisticsParityTest.php
new file mode 100644
index 0000000000..7ce1d3423d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Engine/StatisticsParityTest.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\Engine;
+
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\Tests\Context\StatisticsParityRows;
+use Flow\Parquet\Tests\Mother\ParquetEngineMother;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+use function extension_loaded;
+use function hex2bin;
+use function str_repeat;
+use function var_export;
+
+#[Group('native-extension')]
+final class StatisticsParityTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        if (!extension_loaded('arrow')) {
+            self::markTestSkipped('arrow is not loaded');
+        }
+    }
+
+    /**
+     * DuckDB v1.5.2 `parquet_metadata()` of both engines' files, as physical values. DuckDB shows no nan_count; those
+     * are arrow-rs 60's.
+     */
+    public function test_both_engines_write_the_statistics_duckdb_reads(): void
+    {
+        $expected = [
+            'digits' => [null, null, '10', '9', 0, null, true, true, ColumnOrder::TypeDefined],
+            'long' => [
+                null,
+                null,
+                str_repeat('a', 64),
+                str_repeat('c', 63) . 'd',
+                0,
+                null,
+                false,
+                false,
+                ColumnOrder::TypeDefined,
+            ],
+            'double' => [null, null, -0.0, 0.0, 0, 1, true, true, ColumnOrder::Ieee754TotalOrder],
+            'float' => [null, null, -2.0, 1.5, 0, 1, true, true, ColumnOrder::Ieee754TotalOrder],
+            'decimal' => [-350, 125, -350, 125, 1, null, true, true, ColumnOrder::TypeDefined],
+            'int32' => [-7, 7, -7, 7, 1, null, true, true, ColumnOrder::TypeDefined],
+            'int64' => [1, 3, 1, 3, 1, null, true, true, ColumnOrder::TypeDefined],
+            'uint64' => [null, null, 0, -1, 0, null, true, true, ColumnOrder::TypeDefined],
+            'boolean' => [null, null, false, true, 1, null, true, true, ColumnOrder::TypeDefined],
+            'date' => [10956, 19724, 10956, 19724, 1, null, true, true, ColumnOrder::TypeDefined],
+            'uuid' => [
+                null,
+                null,
+                (string) hex2bin('00000000000000000000000000000002'),
+                (string) hex2bin('ffffffff000000000000000000000001'),
+                1,
+                null,
+                true,
+                true,
+                ColumnOrder::TypeDefined,
+            ],
+            'decimal30' => [
+                (string) hex2bin('fffffffffffffffffffffffea2'),
+                (string) hex2bin('0000000000112210f47de98120'),
+                (string) hex2bin('fffffffffffffffffffffffea2'),
+                (string) hex2bin('0000000000112210f47de98120'),
+                1,
+                null,
+                true,
+                true,
+                ColumnOrder::TypeDefined,
+            ],
+            'binary' => [null, null, "\x00\xff", "\x80", 0, null, true, true, ColumnOrder::TypeDefined],
+            'timestamp' => [
+                -1_000_000,
+                1_704_164_645_123_456,
+                -1_000_000,
+                1_704_164_645_123_456,
+                1,
+                null,
+                true,
+                true,
+                ColumnOrder::TypeDefined,
+            ],
+            'enum' => [null, null, 'BLUE', 'RED', 0, null, true, true, ColumnOrder::TypeDefined],
+        ];
+
+        static::assertSame(
+            var_export($expected, true),
+            var_export(StatisticsParityRows::statistics(ParquetEngineMother::create(PhpParquetEngine::class)), true),
+        );
+        static::assertSame(
+            var_export($expected, true),
+            var_export(StatisticsParityRows::statistics(ParquetEngineMother::create(RustParquetEngine::class)), true),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LegacyStatisticsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LegacyStatisticsTest.php
new file mode 100644
index 0000000000..cb9e35ec53
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LegacyStatisticsTest.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\IO;
+
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Tests\Context\FilePlan;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class LegacyStatisticsTest extends TestCase
+{
+    public function test_a_file_without_column_orders_has_no_trusted_statistics(): void
+    {
+        $metadata = Reader::php()->read(__DIR__
+        . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet')->metadata();
+
+        foreach ($metadata->schema()->columnsFlat() as $column) {
+            static::assertSame(ColumnOrder::Absent, $metadata->columnOrder($column));
+            static::assertFalse(ColumnOrder::Absent->isTrusted($column));
+        }
+    }
+
+    public function test_a_file_without_column_orders_keeps_every_row_group(): void
+    {
+        $file = Reader::php()->read(__DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet');
+
+        static::assertCount(50, $file->metadata()->rowGroups()->all());
+        static::assertEquals(RowSelection::all(5000), FilePlan::of($file, parquet_column('id')->equals(1))->selection);
+        static::assertEquals(
+            RowSelection::all(5000),
+            FilePlan::of($file, parquet_column('name')->equals('name-0'))->selection,
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/ListsReadingTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/ListsReadingTest.php
index ba0064f50e..b8ca62adeb 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/ListsReadingTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/ListsReadingTest.php
@@ -4,6 +4,7 @@
 
 namespace Flow\Parquet\Tests\Integration\IO;
 
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -22,7 +23,7 @@ public function test_reading_list_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['list']) as $row) {
+        foreach ($file->values(new Query(['list'])) as $row) {
             /** @var array<array-key, mixed> $list */
             $list = $row['list'];
             static::assertIsArray($list);
@@ -47,7 +48,7 @@ public function test_reading_list_column_with_limit(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['list'], $limit = 50) as $row) {
+        foreach ($file->values(new Query(['list'], limit: $limit = 50)) as $row) {
             /** @var array<array-key, mixed> $list */
             $list = $row['list'];
             static::assertIsArray($list);
@@ -71,7 +72,7 @@ public function test_reading_list_nested_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['list_nested']) as $row) {
+        foreach ($file->values(new Query(['list_nested'])) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['list_nested'];
             static::assertIsArray($outer);
@@ -103,7 +104,7 @@ public function test_reading_list_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['list_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['list_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 /** @var array<array-key, mixed> $list */
                 $list = $row['list_nullable'];
@@ -132,7 +133,7 @@ public function test_reading_list_of_structures_column(string $engineClass): voi
 
         $count = 0;
 
-        foreach ($file->values(['list_mixed_types']) as $row) {
+        foreach ($file->values(new Query(['list_mixed_types'])) as $row) {
             /** @var array<array-key, mixed> $list */
             $list = $row['list_mixed_types'];
             static::assertIsArray($list);
@@ -168,7 +169,7 @@ public function test_reading_list_of_structures_nullable_column(string $engineCl
 
         $count = 0;
 
-        foreach ($file->values(['list_of_structs_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['list_of_structs_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 // @mago-ignore analysis:mixed-assignment
                 /** @var array<array-key, mixed> $list */
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LogicalTypesReadingTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LogicalTypesReadingTest.php
index ebed7b0692..6290e90367 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LogicalTypesReadingTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/LogicalTypesReadingTest.php
@@ -10,6 +10,7 @@
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\ParquetFile\Schema\Repetition;
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Context\TemporalValues;
 use Flow\Parquet\Tests\Context\TestParquetFile;
@@ -85,7 +86,7 @@ public function test_reading_dates(string $engineClass): void
             TemporalValues::format(
                 (new Reader(engine: $engine))
                     ->read(__DIR__ . '/Fixtures/logical_types.parquet')
-                    ->values(['d']),
+                    ->values(new Query(['d'])),
             ),
         );
     }
@@ -126,7 +127,7 @@ public function test_reading_int_backed_decimals(string $engineClass): void
             iterator_to_array(
                 (new Reader(engine: $engine))
                     ->read(__DIR__ . '/Fixtures/logical_types.parquet')
-                    ->values(['dec9', 'dec18']),
+                    ->values(new Query(['dec9', 'dec18'])),
             ),
         );
     }
@@ -144,7 +145,7 @@ public function test_reading_times_in_every_unit(string $engineClass): void
             TemporalValues::format(
                 (new Reader(engine: $engine))
                     ->read(__DIR__ . '/Fixtures/logical_types.parquet')
-                    ->values(['t_ms', 't_us', 't_ns']),
+                    ->values(new Query(['t_ms', 't_us', 't_ns'])),
             ),
         );
     }
@@ -173,7 +174,7 @@ public function test_reading_timestamps_in_every_unit(string $engineClass): void
             ],
             TemporalValues::format((new Reader(engine: $engine))
                 ->read(__DIR__ . '/Fixtures/logical_types.parquet')
-                ->values(['ts_ms', 'ts_us', 'ts_ns', 'ts_us_utc', 'ts_us_far'])),
+                ->values(new Query(['ts_ms', 'ts_us', 'ts_ns', 'ts_us_utc', 'ts_us_far']))),
         );
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/MapsReadingTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/MapsReadingTest.php
index fcafb31aea..b7fd97af44 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/MapsReadingTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/MapsReadingTest.php
@@ -4,6 +4,7 @@
 
 namespace Flow\Parquet\Tests\Integration\IO;
 
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -24,7 +25,7 @@ public function test_reading_map_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['map']) as $row) {
+        foreach ($file->values(new Query(['map'])) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map'];
             static::assertIsArray($map);
@@ -49,7 +50,7 @@ public function test_reading_map_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['map_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['map_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 /** @var array<array-key, mixed> $map */
                 $map = $row['map_nullable'];
@@ -78,7 +79,7 @@ public function test_reading_map_of_complex_lists(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['map_of_complex_lists']) as $row) {
+        foreach ($file->values(new Query(['map_of_complex_lists'])) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map_of_complex_lists'];
             static::assertIsArray($map);
@@ -112,7 +113,7 @@ public function test_reading_map_of_list_of_map_of_lists(string $engineClass): v
 
         $count = 0;
 
-        foreach ($file->values(['map_of_list_of_map_of_lists']) as $row) {
+        foreach ($file->values(new Query(['map_of_list_of_map_of_lists'])) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map_of_list_of_map_of_lists'];
             static::assertIsArray($map);
@@ -145,7 +146,7 @@ public function test_reading_map_of_lists(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['map_of_lists']) as $row) {
+        foreach ($file->values(new Query(['map_of_lists'])) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map_of_lists'];
             static::assertIsArray($map);
@@ -172,7 +173,7 @@ public function test_reading_map_of_maps_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['map_of_maps']) as $row) {
+        foreach ($file->values(new Query(['map_of_maps'])) as $row) {
             /** @var array<array-key, mixed> $outerMap */
             $outerMap = $row['map_of_maps'];
             static::assertIsArray($outerMap);
@@ -201,7 +202,7 @@ public function test_reading_map_of_struct_of_structs_column(string $engineClass
 
         $count = 0;
 
-        foreach ($file->values(['map_of_struct_of_structs']) as $row) {
+        foreach ($file->values(new Query(['map_of_struct_of_structs'])) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map_of_struct_of_structs'];
             static::assertIsArray($map);
@@ -237,7 +238,7 @@ public function test_reading_map_of_struct_of_structs_column_with_limit(string $
 
         $count = 0;
 
-        foreach ($file->values(['map_of_struct_of_structs'], $limit = 50) as $row) {
+        foreach ($file->values(new Query(['map_of_struct_of_structs'], limit: $limit = 50)) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map_of_struct_of_structs'];
             static::assertIsArray($map);
@@ -269,7 +270,7 @@ public function test_reading_map_of_structs_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['map_of_structs']) as $row) {
+        foreach ($file->values(new Query(['map_of_structs'])) as $row) {
             /** @var array<array-key, mixed> $map */
             $map = $row['map_of_structs'];
             static::assertIsArray($map);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/PaginationTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/PaginationTest.php
index 26d0c20456..cfbb8e6f9b 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/PaginationTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/PaginationTest.php
@@ -4,16 +4,12 @@
 
 namespace Flow\Parquet\Tests\Integration\IO;
 
-use DateTimeImmutable;
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
-use Flow\Parquet\ParquetFile\Schema\ListElement;
-use Flow\Parquet\ParquetFile\Schema\MapKey;
-use Flow\Parquet\ParquetFile\Schema\MapValue;
-use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Context\TestParquetFile;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
@@ -23,11 +19,8 @@
 
 use function array_map;
 use function array_merge;
-use function file_exists;
-use function Flow\ETL\DSL\generate_random_int;
 use function iterator_to_array;
 use function range;
-use function unlink;
 
 class PaginationTest extends ParquetIntegrationTestCase
 {
@@ -68,13 +61,11 @@ public function test_offset_past_first_page_of_multi_page_column(string $engineC
             array_map(static fn(int $i): array => ['id' => $i], range(0, 99)),
         );
 
+        $file = (new Reader(engine: $engine))->read($path);
+
         static::assertSame(
             array_map(static fn(int $i): array => ['id' => $i], range(30, 99)),
-            iterator_to_array(
-                (new Reader(engine: $engine))
-                    ->read($path)
-                    ->values(['id'], offset: 30),
-            ),
+            iterator_to_array($file->values(new Query(['id'], offset: 30))),
         );
     }
 
@@ -89,16 +80,14 @@ public function test_reading_last_100_rows(string $engineClass): void
             ->metadata()
             ->rowsNumber();
 
+        $file = (new Reader(engine: $engine))->read($path);
+
         static::assertEquals(
             array_merge(...array_map(
                 static fn(int $i): array => [['id' => $i]],
                 range($totalRows - 100, $totalRows - 1),
             )),
-            iterator_to_array(
-                (new Reader(engine: $engine))
-                    ->read($path)
-                    ->values(['id'], offset: $totalRows - 100),
-            ),
+            iterator_to_array($file->values(new Query(['id'], offset: $totalRows - 100))),
         );
     }
 
@@ -112,45 +101,11 @@ public function test_setting_offset_larger_than_file(
         $engine = ParquetEngineMother::create($engineClass);
         $path = __DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet';
 
+        $file = (new Reader(engine: $engine))->read($path);
+
         static::assertCount(
             $results,
-            iterator_to_array(
-                (new Reader(engine: $engine))
-                    ->read($path)
-                    ->values(['id'], offset: $offset, limit: $limit),
-            ),
-        );
-    }
-
-    #[DataProvider('engine_provider')]
-    public function test_setting_setting_limit_to_negative(string $engineClass): void
-    {
-        $engine = ParquetEngineMother::create($engineClass);
-        $path = __DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet';
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Limit must be greater than 0');
-
-        iterator_to_array(
-            (new Reader(engine: $engine))
-                ->read($path)
-                ->values(['id'], limit: -2),
-        );
-    }
-
-    #[DataProvider('engine_provider')]
-    public function test_setting_setting_offset_to_negative(string $engineClass): void
-    {
-        $engine = ParquetEngineMother::create($engineClass);
-        $path = __DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet';
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Offset must be greater than or equal to 0');
-
-        iterator_to_array(
-            (new Reader(engine: $engine))
-                ->read($path)
-                ->values(['id'], offset: -2, limit: 2),
+            iterator_to_array($file->values(new Query(['id'], offset: $offset, limit: $limit))),
         );
     }
 
@@ -164,36 +119,17 @@ public function test_columns_refuses_a_batch_size_below_one(string $engineClass)
         iterator_to_array(
             (new Reader(engine: $engine))
                 ->read(__DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet')
-                ->columns(0, ['id']),
+                ->columns(new Query(['id']), 0),
         );
     }
 
     #[DataProvider('engine_provider')]
-    public function test_columns_refuses_a_limit_of_zero(string $engineClass): void
+    public function test_columns_with_a_limit_of_zero_read_no_row(string $engineClass): void
     {
-        $engine = ParquetEngineMother::create($engineClass);
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Limit must be greater than 0');
+        $file = (new Reader(engine: ParquetEngineMother::create($engineClass)))->read(__DIR__
+        . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet');
 
-        iterator_to_array(
-            (new Reader(engine: $engine))
-                ->read(__DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet')
-                ->columns(2, ['id'], limit: 0),
-        );
-    }
-
-    #[DataProvider('engine_provider')]
-    public function test_columns_refuses_a_negative_offset_without_a_limit(string $engineClass): void
-    {
-        $engine = ParquetEngineMother::create($engineClass);
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Offset must be greater than or equal to 0');
-
-        iterator_to_array(
-            (new Reader(engine: $engine))
-                ->read(__DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet')
-                ->columns(2, ['id'], offset: -1),
-        );
+        static::assertSame([], iterator_to_array($file->columns(new Query(['id'], limit: 0), 2)));
     }
 
     #[DataProvider('engine_provider')]
@@ -206,7 +142,7 @@ public function test_columns_refuses_an_unknown_column(string $engineClass): voi
         iterator_to_array(
             (new Reader(engine: $engine))
                 ->read(__DIR__ . '/Fixtures/pagination_row_group_1kb_5k_rows.snappy.parquet')
-                ->columns(2, ['nope']),
+                ->columns(new Query(['nope']), 2),
         );
     }
 
@@ -219,14 +155,16 @@ public function test_values_equal_the_zip_of_columns(string $engineClass): void
 
         $zipped = [];
 
-        foreach ($file->columns(3, ['id', 'name'], limit: 7, offset: 1020) as $chunk) {
+        $query = new Query(['id', 'name'], offset: 1020, limit: 7);
+
+        foreach ($file->columns($query, 3) as $chunk) {
             // @mago-ignore analysis:mixed-assignment
             foreach ($chunk['id'] as $i => $id) {
                 $zipped[] = ['id' => $id, 'name' => $chunk['name'][$i]];
             }
         }
 
-        static::assertSame($zipped, iterator_to_array($file->values(['id', 'name'], limit: 7, offset: 1020), false));
+        static::assertSame($zipped, iterator_to_array($file->values($query), false));
         static::assertCount(7, $zipped);
     }
 
@@ -239,71 +177,11 @@ public function test_simple_pagination_on_small_row_group_size(string $engineCla
         // Uncomment only to apply changes to the dataset
         // $this->generateDataset($path);
 
+        $file = (new Reader(engine: $engine))->read($path);
+
         static::assertEquals(
             array_merge(...array_map(static fn(int $i): array => [['id' => $i]], range(1020, 1029))),
-            iterator_to_array(
-                (new Reader(engine: $engine))
-                    ->read($path)
-                    ->values(['id'], offset: 1020, limit: 10),
-            ),
+            iterator_to_array($file->values(new Query(['id'], offset: 1020, limit: 10))),
         );
     }
-
-    private function _generateDataset(string $path): void
-    {
-        $writer = new Writer(options: Options::default()->set(Option::ROW_GROUP_SIZE_BYTES, 1024)->set(
-            Option::ROW_GROUP_SIZE_CHECK_INTERVAL,
-            100,
-        ));
-        $schema = Schema::with(
-            FlatColumn::int64('id'),
-            FlatColumn::string('name'),
-            FlatColumn::boolean('active'),
-            FlatColumn::dateTime('created_at'),
-            NestedColumn::list('list_of_int', ListElement::int32()),
-            NestedColumn::map('map_of_int_string', MapKey::int32(), MapValue::string()),
-            NestedColumn::struct('struct', [
-                FlatColumn::int64('id'),
-                FlatColumn::string('name'),
-                FlatColumn::boolean('active'),
-                FlatColumn::dateTime('created_at'),
-                NestedColumn::list('list_of_int', ListElement::int32()),
-                NestedColumn::map('map_of_int_string', MapKey::int32(), MapValue::string()),
-            ]),
-        );
-
-        $inputData = array_merge(...array_map(
-            static fn(int $i): array => [
-                [
-                    'id' => $i,
-                    'name' => 'name-' . $i,
-                    'active' => ($i % 2) === 0,
-                    'created_at' => new DateTimeImmutable('2024-01-01 + ' . $i . ' days'),
-                    'list_of_int' => array_map(static fn(int $i) => $i, range(1, generate_random_int(2, 10))),
-                    'map_of_int_string' => array_merge(...array_map(
-                        static fn(int $i) => [$i => 'value-' . $i],
-                        range(1, generate_random_int(2, 10)),
-                    )),
-                    'struct' => [
-                        'id' => $i,
-                        'name' => 'name-' . $i,
-                        'active' => ($i % 2) === 0,
-                        'created_at' => new DateTimeImmutable('2024-01-01 + ' . $i . ' days'),
-                        'list_of_int' => array_map(static fn(int $i) => $i, range(1, generate_random_int(2, 10))),
-                        'map_of_int_string' => array_merge(...array_map(
-                            static fn(int $i) => [$i => 'value-' . $i],
-                            range(1, generate_random_int(2, 10)),
-                        )),
-                    ],
-                ],
-            ],
-            range(0, 4999),
-        ));
-
-        if (file_exists($path)) {
-            unlink($path);
-        }
-
-        $writer->write($path, $schema, $inputData);
-    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SchemaReadingTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SchemaReadingTest.php
index 8908e21f24..5059bb03bc 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SchemaReadingTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SchemaReadingTest.php
@@ -6,11 +6,15 @@
 
 use Flow\Parquet\ParquetFile\RowGroup\StatisticsReader;
 use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\MapKey;
 use Flow\Parquet\ParquetFile\Schema\MapValue;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Schema\Repetition;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -140,8 +144,27 @@ public function test_reading_primitives_schema_ddl(string $engineClass): void
             FlatColumn::float('float_nullable'),
             FlatColumn::double('double'),
             FlatColumn::double('double_nullable'),
-            FlatColumn::decimal('decimal'),
-            FlatColumn::decimal('decimal_nullable'),
+            // pyarrow stores decimal(10, 2) as FIXED_LEN_BYTE_ARRAY(5)
+            new FlatColumn(
+                'decimal',
+                PhysicalType::FIXED_LEN_BYTE_ARRAY,
+                ConvertedType::DECIMAL,
+                LogicalType::decimal(2, 10),
+                Repetition::OPTIONAL,
+                10,
+                2,
+                5,
+            ),
+            new FlatColumn(
+                'decimal_nullable',
+                PhysicalType::FIXED_LEN_BYTE_ARRAY,
+                ConvertedType::DECIMAL,
+                LogicalType::decimal(2, 10),
+                Repetition::OPTIONAL,
+                10,
+                2,
+                5,
+            ),
         );
 
         static::assertSame(
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SimpleTypesReadingTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SimpleTypesReadingTest.php
index 50f580208b..17955eed43 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SimpleTypesReadingTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/SimpleTypesReadingTest.php
@@ -7,6 +7,7 @@
 use DateInterval;
 use DateTimeImmutable;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -31,7 +32,7 @@ public function test_reading_bool_column(string $engineClass): void
         static::assertNull($file->metadata()->schema()->get('bool')->logicalType());
 
         /** @var array<string, mixed> $results */
-        $results = array_merge_recursive(...iterator_to_array($file->values(['bool'])))['bool'];
+        $results = array_merge_recursive(...iterator_to_array($file->values(new Query(['bool']))))['bool'];
         static::assertIsArray($results);
         static::assertCount(100, $results);
         static::assertContainsOnlyBool($results);
@@ -49,7 +50,7 @@ public function test_reading_bool_column_with_limit(string $engineClass): void
         static::assertNull($file->metadata()->schema()->get('bool')->logicalType());
 
         /** @var array<string, mixed> $results */
-        $results = array_merge_recursive(...iterator_to_array($file->values(['bool'], limit: 50)))['bool'];
+        $results = array_merge_recursive(...iterator_to_array($file->values(new Query(['bool'], limit: 50))))['bool'];
         static::assertIsArray($results);
         static::assertCount(50, $results);
         static::assertContainsOnlyBool($results);
@@ -66,7 +67,9 @@ public function test_reading_bool_nullable_column(string $engineClass): void
         static::assertNull($file->metadata()->schema()->get('bool_nullable')->logicalType());
 
         /** @var array<string, mixed> $results */
-        $results = array_merge_recursive(...iterator_to_array($file->values(['bool_nullable'])))['bool_nullable'];
+        $results = array_merge_recursive(...iterator_to_array($file->values(new Query([
+            'bool_nullable',
+        ]))))['bool_nullable'];
         static::assertIsArray($results);
         static::assertCount(100, $results);
         static::assertSame($file->metadata()->rowsNumber(), count($results));
@@ -86,8 +89,7 @@ public function test_reading_bool_nullable_column_with_limit(string $engineClass
 
         /** @var array<string, mixed> $results */
         $results = array_merge_recursive(...iterator_to_array($file->values(
-            ['bool_nullable'],
-            $limit = 50,
+            new Query(['bool_nullable'], limit: $limit = 50),
         )))['bool_nullable'];
         static::assertIsArray($results);
         static::assertCount($limit, $results);
@@ -107,7 +109,7 @@ public function test_reading_date_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['date']) as $row) {
+        foreach ($file->values(new Query(['date'])) as $row) {
             static::assertInstanceOf(DateTimeImmutable::class, $row['date']);
             $count++;
         }
@@ -127,7 +129,7 @@ public function test_reading_date_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['date_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['date_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertInstanceOf(DateTimeImmutable::class, $row['date_nullable']);
             } else {
@@ -150,7 +152,7 @@ public function test_reading_decimal_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['decimal']) as $row) {
+        foreach ($file->values(new Query(['decimal'])) as $row) {
             static::assertIsFloat($row['decimal']);
             $count++;
         }
@@ -172,7 +174,7 @@ public function test_reading_decimal_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['decimal_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['decimal_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsFloat($row['decimal_nullable']);
             } else {
@@ -208,7 +210,7 @@ public function test_reading_delta_binary_packed_encoded_integers(string $engine
         $floatValues = [];
         $count = 0;
 
-        foreach ($file->values(['int32_column', 'int64_column', 'float_column']) as $row) {
+        foreach ($file->values(new Query(['int32_column', 'int64_column', 'float_column'])) as $row) {
             $int32Values[] = $row['int32_column'];
             $int64Values[] = $row['int64_column'];
             $floatValues[] = $row['float_column'];
@@ -265,7 +267,7 @@ public function test_reading_double_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['double']) as $row) {
+        foreach ($file->values(new Query(['double'])) as $row) {
             static::assertIsFloat($row['double']);
             $count++;
         }
@@ -284,7 +286,7 @@ public function test_reading_double_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['double_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['double_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsFloat($row['double_nullable']);
             } else {
@@ -308,7 +310,7 @@ public function test_reading_enum_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['enum']) as $row) {
+        foreach ($file->values(new Query(['enum'])) as $row) {
             static::assertIsString($row['enum']);
             $count++;
         }
@@ -327,7 +329,7 @@ public function test_reading_float_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['float']) as $row) {
+        foreach ($file->values(new Query(['float'])) as $row) {
             static::assertIsFloat($row['float']);
             $count++;
         }
@@ -346,7 +348,7 @@ public function test_reading_float_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['float_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['float_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsFloat($row['float_nullable']);
             } else {
@@ -370,7 +372,7 @@ public function test_reading_int32_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['int32']) as $row) {
+        foreach ($file->values(new Query(['int32'])) as $row) {
             static::assertIsInt($row['int32']);
             $count++;
         }
@@ -390,7 +392,7 @@ public function test_reading_int32_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['int32_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['int32_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsInt($row['int32_nullable']);
             } else {
@@ -414,7 +416,7 @@ public function test_reading_int64(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['int64']) as $row) {
+        foreach ($file->values(new Query(['int64'])) as $row) {
             static::assertIsInt($row['int64']);
             $count++;
         }
@@ -435,7 +437,7 @@ public function test_reading_int64_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['int64_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['int64_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsInt($row['int64_nullable']);
             } else {
@@ -459,7 +461,7 @@ public function test_reading_json_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['json']) as $row) {
+        foreach ($file->values(new Query(['json'])) as $row) {
             static::assertIsString($row['json']);
             $count++;
         }
@@ -479,7 +481,7 @@ public function test_reading_json_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['json_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['json_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsString($row['json_nullable']);
             } else {
@@ -503,7 +505,7 @@ public function test_reading_string_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['string']) as $row) {
+        foreach ($file->values(new Query(['string'])) as $row) {
             static::assertIsString($row['string']);
             $count++;
         }
@@ -523,7 +525,7 @@ public function test_reading_string_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['string_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['string_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsString($row['string_nullable']);
             } else {
@@ -547,7 +549,7 @@ public function test_reading_time_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['time']) as $row) {
+        foreach ($file->values(new Query(['time'])) as $row) {
             static::assertInstanceOf(DateInterval::class, $row['time']);
             $count++;
         }
@@ -567,7 +569,7 @@ public function test_reading_time_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['time_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['time_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertInstanceOf(DateInterval::class, $row['time_nullable']);
             } else {
@@ -591,7 +593,7 @@ public function test_reading_timestamp_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['timestamp']) as $row) {
+        foreach ($file->values(new Query(['timestamp'])) as $row) {
             static::assertInstanceOf(DateTimeImmutable::class, $row['timestamp']);
             $count++;
         }
@@ -614,7 +616,7 @@ public function test_reading_timestamp_nullable_column(string $engineClass): voi
 
         $count = 0;
 
-        foreach ($file->values(['timestamp_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['timestamp_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertInstanceOf(DateTimeImmutable::class, $row['timestamp_nullable']);
             } else {
@@ -638,7 +640,7 @@ public function test_reading_uuid_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['uuid']) as $row) {
+        foreach ($file->values(new Query(['uuid'])) as $row) {
             static::assertIsString($row['uuid']);
             $count++;
         }
@@ -658,7 +660,7 @@ public function test_reading_uuid_nullable_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['uuid_nullable']) as $rowIndex => $row) {
+        foreach ($file->values(new Query(['uuid_nullable'])) as $rowIndex => $row) {
             if (($rowIndex % 2) === 0) {
                 static::assertIsString($row['uuid_nullable']);
             } else {
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/StructsReadingTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/StructsReadingTest.php
index e41955f8e9..b37fad4c1e 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/StructsReadingTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/StructsReadingTest.php
@@ -4,6 +4,7 @@
 
 namespace Flow\Parquet\Tests\Integration\IO;
 
+use Flow\Parquet\Query;
 use Flow\Parquet\Reader;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -22,7 +23,7 @@ public function test_reading_struct_deeply_nested_column(string $engineClass): v
 
         $count = 0;
 
-        foreach ($file->values(['struct_deeply_nested']) as $row) {
+        foreach ($file->values(new Query(['struct_deeply_nested'])) as $row) {
             /** @var array<array-key, mixed> $deep */
             $deep = $row['struct_deeply_nested'];
             static::assertIsArray($deep);
@@ -70,7 +71,7 @@ public function test_reading_struct_deeply_nested_column_with_limit(string $engi
 
         $count = 0;
 
-        foreach ($file->values(['struct_deeply_nested'], $limit = 50) as $row) {
+        foreach ($file->values(new Query(['struct_deeply_nested'], limit: $limit = 50)) as $row) {
             /** @var array<array-key, mixed> $deep */
             $deep = $row['struct_deeply_nested'];
             static::assertIsArray($deep);
@@ -117,7 +118,7 @@ public function test_reading_struct_flat_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['struct_flat']) as $row) {
+        foreach ($file->values(new Query(['struct_flat'])) as $row) {
             /** @var array<array-key, mixed> $flat */
             $flat = $row['struct_flat'];
             static::assertIsArray($flat);
@@ -143,7 +144,7 @@ public function test_reading_struct_flat_nullable_column(string $engineClass): v
 
         $count = 0;
 
-        foreach ($file->values(['struct_flat_nullable']) as $i => $row) {
+        foreach ($file->values(new Query(['struct_flat_nullable'])) as $i => $row) {
             if (($i % 2) === 0) {
                 /** @var array<array-key, mixed> $flat */
                 $flat = $row['struct_flat_nullable'];
@@ -173,7 +174,7 @@ public function test_reading_struct_nested_column(string $engineClass): void
 
         $count = 0;
 
-        foreach ($file->values(['struct_nested']) as $row) {
+        foreach ($file->values(new Query(['struct_nested'])) as $row) {
             /** @var array<array-key, mixed> $nested */
             $nested = $row['struct_nested'];
             static::assertIsArray($nested);
@@ -203,7 +204,7 @@ public function test_reading_struct_nested_with_list_of_lists_column(string $eng
 
         $count = 0;
 
-        foreach ($file->values(['struct_nested_with_list_of_lists']) as $row) {
+        foreach ($file->values(new Query(['struct_nested_with_list_of_lists'])) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['struct_nested_with_list_of_lists'];
             static::assertIsArray($outer);
@@ -232,7 +233,7 @@ public function test_reading_struct_nested_with_list_of_maps_column(string $engi
 
         $count = 0;
 
-        foreach ($file->values(['struct_nested_with_list_of_maps']) as $row) {
+        foreach ($file->values(new Query(['struct_nested_with_list_of_maps'])) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['struct_nested_with_list_of_maps'];
             static::assertIsArray($outer);
@@ -261,7 +262,7 @@ public function test_reading_struct_nested_with_map_of_list_of_ints_column(strin
 
         $count = 0;
 
-        foreach ($file->values(['struct_nested_with_map_of_list_of_ints']) as $row) {
+        foreach ($file->values(new Query(['struct_nested_with_map_of_list_of_ints'])) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['struct_nested_with_map_of_list_of_ints'];
             static::assertIsArray($outer);
@@ -298,7 +299,7 @@ public function test_reading_struct_nested_with_map_of_string_map_of_string_stri
 
         $count = 0;
 
-        foreach ($file->values(['struct_nested_with_map_of_string_map_of_string_string']) as $row) {
+        foreach ($file->values(new Query(['struct_nested_with_map_of_string_map_of_string_string'])) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['struct_nested_with_map_of_string_map_of_string_string'];
             static::assertIsArray($outer);
@@ -339,7 +340,9 @@ public function test_reading_struct_nested_with_map_of_string_map_of_string_stri
 
         $count = 0;
 
-        foreach ($file->values(['struct_nested_with_map_of_string_map_of_string_string'], $limit = 50) as $row) {
+        foreach ($file->values(
+            new Query(['struct_nested_with_map_of_string_map_of_string_string'], limit: $limit = 50),
+        ) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['struct_nested_with_map_of_string_map_of_string_string'];
             static::assertIsArray($outer);
@@ -375,7 +378,7 @@ public function test_reading_struct_with_list_and_map_of_structs_column(string $
 
         $count = 0;
 
-        foreach ($file->values(['struct_with_list_and_map_of_structs']) as $row) {
+        foreach ($file->values(new Query(['struct_with_list_and_map_of_structs'])) as $row) {
             /** @var array<array-key, mixed> $outer */
             $outer = $row['struct_with_list_and_map_of_structs'];
             static::assertIsArray($outer);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/WriterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/WriterTest.php
index 4c4dd581f4..6ac0165e15 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/WriterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/IO/WriterTest.php
@@ -5,34 +5,62 @@
 namespace Flow\Parquet\Tests\Integration\IO;
 
 use Composer\InstalledVersions;
-use Faker\Factory;
 use Flow\Filesystem\Exception\RuntimeException as FilesystemRuntimeException;
 use Flow\Filesystem\Stream\NativeLocalDestinationStream;
 use Flow\Filesystem\Tests\Double\FailingCloseDestinationStream;
-use Flow\Parquet\Consts;
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\BloomFilter\BloomHash;
 use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Engine\RustParquetEngine;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\Page\ColumnPageHeader;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
 use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Time;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Timestamp;
 use Flow\Parquet\ParquetFile\Schema\MapKey;
 use Flow\Parquet\ParquetFile\Schema\MapValue;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
 use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Context\ParquetRows;
+use Flow\Parquet\Tests\Context\StructWithLists;
 use Flow\Parquet\Tests\Context\TestParquetFile;
 use Flow\Parquet\Tests\Mother\ParquetEngineMother;
 use Flow\Parquet\Writer;
+use Flow\Parquet\Writer\StatisticsLevel;
+use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
 use RuntimeException;
 
+use function array_combine;
 use function array_map;
-use function Flow\ETL\DSL\generate_random_int;
+use function array_unique;
+use function array_values;
+use function count;
+use function extension_loaded;
 use function Flow\Filesystem\DSL\memory_filesystem;
 use function Flow\Filesystem\DSL\path;
 use function fopen;
 use function iterator_to_array;
+use function pack;
 use function range;
+use function str_repeat;
+use function unpack;
+use function var_export;
+
+use const NAN;
 
 class WriterTest extends ParquetIntegrationTestCase
 {
@@ -80,7 +108,7 @@ public function test_created_by_metadata(): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
+        $schema = StructWithLists::schema();
         $writer->open($path, $schema);
         $writer->close();
 
@@ -100,7 +128,7 @@ public function test_opening_already_open_writer(string $engineClass): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
+        $schema = StructWithLists::schema();
 
         $writer->open($path, $schema);
 
@@ -225,7 +253,7 @@ public function test_writing_batch_to_not_open_stream(string $engineClass): void
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage('Writer is not open');
 
-        $writer->writeBatch([$this->createRow()]);
+        $writer->writeBatch([StructWithLists::row()]);
     }
 
     #[DataProvider('engine_provider')]
@@ -256,6 +284,210 @@ public function test_writing_column_statistics(string $engineClass): void
         static::assertFileExists($path);
     }
 
+    #[DataProvider('engine_provider')]
+    public function test_writing_column_orders_per_leaf(string $engineClass): void
+    {
+        $engine = ParquetEngineMother::create($engineClass);
+        $path = TestParquetFile::path($this);
+        (new Writer(engine: $engine))->write(
+            $path,
+            Schema::with(
+                FlatColumn::string('string'),
+                FlatColumn::double('double'),
+                FlatColumn::float('float'),
+                FlatColumn::int64('int64'),
+                NestedColumn::list('list', ListElement::double()),
+                NestedColumn::map('map', MapKey::string(), MapValue::int32()),
+                NestedColumn::struct('struct', [FlatColumn::double('x'), FlatColumn::boolean('flag')]),
+            ),
+            [[
+                'string' => 'a',
+                'double' => 1.5,
+                'float' => 2.5,
+                'int64' => 1,
+                'list' => [1.5],
+                'map' => ['a' => 1],
+                'struct' => ['x' => 1.5, 'flag' => true],
+            ]],
+        );
+
+        $metadata = (new Reader(engine: $engine))
+            ->read($path)
+            ->metadata();
+
+        static::assertSame(
+            [
+                'string' => ColumnOrder::TypeDefined,
+                'double' => ColumnOrder::Ieee754TotalOrder,
+                'float' => ColumnOrder::Ieee754TotalOrder,
+                'int64' => ColumnOrder::TypeDefined,
+                'list.list.element' => ColumnOrder::Ieee754TotalOrder,
+                'map.key_value.key' => ColumnOrder::TypeDefined,
+                'map.key_value.value' => ColumnOrder::TypeDefined,
+                'struct.x' => ColumnOrder::Ieee754TotalOrder,
+                'struct.flag' => ColumnOrder::TypeDefined,
+            ],
+            array_combine(
+                array_map(
+                    static fn(FlatColumn $column): string => $column->flatPath(),
+                    $metadata->schema()->columnsFlat(),
+                ),
+                array_map($metadata->columnOrder(...), $metadata->schema()->columnsFlat()),
+            ),
+        );
+    }
+
+    #[DataProvider('engine_provider')]
+    public function test_writing_float_statistics_in_total_order_with_nan_count(string $engineClass): void
+    {
+        $engine = ParquetEngineMother::create($engineClass);
+        $path = TestParquetFile::path($this);
+        $column = FlatColumn::double('double');
+
+        (new Writer(engine: $engine))->write(
+            $path,
+            Schema::with($column),
+            array_map(static fn(float $value): array => [
+                'double' => $value,
+            ], [NAN, 0.0, -0.0, 1.5, NAN]),
+        );
+
+        $statistics = (new Reader(engine: $engine))
+            ->read($path)
+            ->metadata()
+            ->columnChunks()[0]->statistics();
+
+        static::assertNotNull($statistics);
+        static::assertSame('-0.0', var_export($statistics->minValue($column), true));
+        static::assertSame(1.5, $statistics->maxValue($column));
+        static::assertSame(2, $statistics->nanCount());
+        static::assertNull($statistics->min($column));
+        static::assertNull($statistics->max($column));
+        static::assertTrue($statistics->isMinValueExact());
+        static::assertTrue($statistics->isMaxValueExact());
+    }
+
+    #[DataProvider('engine_pair_provider')]
+    public function test_writing_uint64_reads_back_as_decimal_strings_on_both_engines(
+        string $writerEngine,
+        string $readerEngine,
+    ): void {
+        $path = TestParquetFile::path($this);
+
+        (new Writer(engine: ParquetEngineMother::create($writerEngine)))->write(
+            $path,
+            Schema::with(new FlatColumn('u', PhysicalType::INT64, logicalType: LogicalType::integer(64, false))),
+            [['u' => 0], ['u' => '9223372036854775808'], ['u' => '18446744073709551615']],
+        );
+
+        static::assertSame(
+            [['u' => '0'], ['u' => '9223372036854775808'], ['u' => '18446744073709551615']],
+            ParquetRows::read((new Reader(engine: ParquetEngineMother::create($readerEngine)))->read($path), 10),
+        );
+    }
+
+    /**
+     * arrow-rs 60 basic.rs `ConvertedType::from(Option<LogicalType>)`, copied by value.
+     *
+     * @return Generator<string, array{FlatColumn, ?ConvertedType}>
+     */
+    public static function converted_types(): Generator
+    {
+        $logical = static fn(
+            PhysicalType $physical,
+            LogicalType $type,
+            ?int $length = null,
+        ): FlatColumn => new FlatColumn('c', $physical, logicalType: $type, typeLength: $length);
+
+        yield 'string' => [$logical(PhysicalType::BYTE_ARRAY, LogicalType::string()), ConvertedType::UTF8];
+        yield 'enum' => [$logical(PhysicalType::BYTE_ARRAY, LogicalType::enum()), ConvertedType::ENUM];
+        yield 'json' => [$logical(PhysicalType::BYTE_ARRAY, LogicalType::json()), ConvertedType::JSON];
+        yield 'bson' => [$logical(PhysicalType::BYTE_ARRAY, LogicalType::bson()), ConvertedType::BSON];
+        yield 'decimal' => [
+            new FlatColumn('c', PhysicalType::INT64, logicalType: LogicalType::decimal(2, 10), precision: 10, scale: 2),
+            ConvertedType::DECIMAL,
+        ];
+        yield 'date' => [$logical(PhysicalType::INT32, LogicalType::date()), ConvertedType::DATE];
+        yield 'time millis' => [
+            $logical(
+                PhysicalType::INT32,
+                new LogicalType(LogicalType::TIME, time: new Time(true, TimeUnit::MILLISECONDS)),
+            ),
+            ConvertedType::TIME_MILLIS,
+        ];
+        yield 'time micros' => [$logical(PhysicalType::INT64, LogicalType::time()), ConvertedType::TIME_MICROS];
+        yield 'time nanos' => [
+            $logical(
+                PhysicalType::INT64,
+                new LogicalType(LogicalType::TIME, time: new Time(true, TimeUnit::NANOSECONDS)),
+            ),
+            null,
+        ];
+        yield 'timestamp millis' => [
+            $logical(
+                PhysicalType::INT64,
+                new LogicalType(LogicalType::TIMESTAMP, timestamp: new Timestamp(true, TimeUnit::MILLISECONDS)),
+            ),
+            ConvertedType::TIMESTAMP_MILLIS,
+        ];
+        yield 'timestamp micros' => [
+            $logical(PhysicalType::INT64, LogicalType::timestamp()),
+            ConvertedType::TIMESTAMP_MICROS,
+        ];
+        yield 'timestamp nanos' => [
+            $logical(
+                PhysicalType::INT64,
+                new LogicalType(LogicalType::TIMESTAMP, timestamp: new Timestamp(true, TimeUnit::NANOSECONDS)),
+            ),
+            null,
+        ];
+        yield 'int8' => [$logical(PhysicalType::INT32, LogicalType::integer(8, true)), ConvertedType::INT_8];
+        yield 'int16' => [$logical(PhysicalType::INT32, LogicalType::integer(16, true)), ConvertedType::INT_16];
+        yield 'int32' => [$logical(PhysicalType::INT32, LogicalType::integer(32, true)), ConvertedType::INT_32];
+        yield 'int64' => [$logical(PhysicalType::INT64, LogicalType::integer(64, true)), ConvertedType::INT_64];
+        yield 'uint8' => [$logical(PhysicalType::INT32, LogicalType::integer(8, false)), ConvertedType::UINT_8];
+        yield 'uint16' => [$logical(PhysicalType::INT32, LogicalType::integer(16, false)), ConvertedType::UINT_16];
+        yield 'uint32' => [$logical(PhysicalType::INT32, LogicalType::integer(32, false)), ConvertedType::UINT_32];
+        yield 'uint64' => [$logical(PhysicalType::INT64, LogicalType::integer(64, false)), ConvertedType::UINT_64];
+        yield 'uuid' => [$logical(PhysicalType::FIXED_LEN_BYTE_ARRAY, LogicalType::uuid(), 16), null];
+        yield 'float16' => [
+            $logical(PhysicalType::FIXED_LEN_BYTE_ARRAY, new LogicalType(LogicalType::FLOAT16), 2),
+            null,
+        ];
+    }
+
+    #[DataProvider('converted_types')]
+    public function test_writing_the_converted_type_of_a_logical_type(
+        FlatColumn $column,
+        ?ConvertedType $expected,
+    ): void {
+        $path = TestParquetFile::path($this);
+
+        (new Writer(engine: new PhpParquetEngine()))->write($path, Schema::with($column), []);
+
+        static::assertSame(
+            $expected?->value,
+            Reader::php()->read($path)->metadata()->toThrift()->schema[1]->converted_type,
+        );
+    }
+
+    #[DataProvider('engine_pair_provider')]
+    public function test_an_int16_column_round_trips(string $writerEngine, string $readerEngine): void
+    {
+        $path = TestParquetFile::path($this);
+
+        (new Writer(engine: ParquetEngineMother::create($writerEngine)))->write(
+            $path,
+            Schema::with(new FlatColumn('s', PhysicalType::INT32, ConvertedType::INT_16)),
+            [['s' => 1], ['s' => -2], ['s' => 32_767], ['s' => null]],
+        );
+
+        static::assertSame(
+            [['s' => 1], ['s' => -2], ['s' => 32_767], ['s' => null]],
+            ParquetRows::read((new Reader(engine: ParquetEngineMother::create($readerEngine)))->read($path), 10),
+        );
+    }
+
     #[DataProvider('engine_provider')]
     public function test_writing_column_statistics_with_null_values(string $engineClass): void
     {
@@ -292,7 +524,7 @@ public function test_writing_column_statistics_with_null_values(string $engineCl
 
     public function test_writing_data_page_v2_statistics(): void
     {
-        $options = Options::default()->set(Option::WRITER_VERSION, 2);
+        $options = Options::default()->set(Option::WRITER_VERSION, 2)->set(Option::PAGE_HEADER_STATISTICS, true);
         $writer = Writer::php(options: $options);
 
         $path = TestParquetFile::path($this);
@@ -306,7 +538,7 @@ public function test_writing_data_page_v2_statistics(): void
             ->pageHeaders() as $pageHeader) {
             $dataPageHeaderV2 = $pageHeader->pageHeader->dataPageHeaderV2();
             static::assertNotNull($dataPageHeaderV2);
-            $statistics = $dataPageHeaderV2->statistics($options);
+            $statistics = $dataPageHeaderV2->statistics();
             static::assertNotNull($statistics);
 
             static::assertSame(1, $statistics->min($column));
@@ -326,9 +558,9 @@ public function test_writing_in_batches_to_file(string $engineClass): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
+        $schema = StructWithLists::schema();
 
-        $row = $this->createRow();
+        $row = StructWithLists::row();
 
         $writer->open($path, $schema);
         $writer->writeBatch([$row, $row]);
@@ -358,9 +590,9 @@ public function test_writing_in_batches_to_file_without_explicit_close(string $e
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
+        $schema = StructWithLists::schema();
 
-        $row = $this->createRow();
+        $row = StructWithLists::row();
         $writer->open($path, $schema);
         $writer->writeBatch([$row, $row]);
         $writer->writeBatch([$row, $row]);
@@ -389,9 +621,9 @@ public function test_writing_in_batches_to_stream(string $engineClass): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
+        $schema = StructWithLists::schema();
 
-        $row = $this->createRow();
+        $row = StructWithLists::row();
 
         $stream = fopen($path, 'wb+');
         $writer->openForStream(new NativeLocalDestinationStream(path($path), $stream), $schema);
@@ -467,7 +699,7 @@ public function test_writing_row_to_not_open_stream(string $engineClass): void
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage('Writer is not open');
 
-        $writer->writeRow($this->createRow());
+        $writer->writeRow(StructWithLists::row());
     }
 
     #[DataProvider('engine_provider')]
@@ -478,8 +710,8 @@ public function test_writing_to_file(string $engineClass): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
-        $row = $this->createRow();
+        $schema = StructWithLists::schema();
+        $row = StructWithLists::row();
 
         $writer->write($path, $schema, [$row, $row, $row, $row, $row, $row, $row, $row, $row, $row]);
 
@@ -502,8 +734,8 @@ public function test_writing_to_file_v2(string $engineClass): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
-        $row = $this->createRow();
+        $schema = StructWithLists::schema();
+        $row = StructWithLists::row();
 
         $writer->write($path, $schema, [$row, $row, $row, $row, $row, $row, $row, $row, $row, $row]);
 
@@ -533,8 +765,8 @@ public function test_writing_to_stream(string $engineClass): void
 
         $path = TestParquetFile::path($this);
 
-        $schema = $this->createSchema();
-        $row = $this->createRow();
+        $schema = StructWithLists::schema();
+        $row = StructWithLists::row();
 
         $stream = fopen($path, 'wb+');
 
@@ -646,37 +878,205 @@ public function test_writing_with_empty_lists_and_maps(string $engineClass): voi
         );
     }
 
-    /**
-     * @return array<string, mixed>
-     */
-    private function createRow(): array
-    {
-        $faker = Factory::create();
-
-        return [
-            'struct' => [
-                'int64' => $faker->numberBetween(0, Consts::PHP_INT64_MAX),
-                'boolean' => $faker->boolean(),
-                'string' => $faker->text(150),
-                'int32' => $faker->numberBetween(0, Consts::PHP_INT32_MAX),
-                'list_of_int' => array_map(
-                    static fn($i) => $faker->numberBetween(0, Consts::PHP_INT32_MAX),
-                    range(1, generate_random_int(2, 10)),
+    public function test_the_page_index_is_written_and_reads_back_on_both_engines(): void
+    {
+        $bytes = MemoryParquetFile::written(
+            Writer::php(options: (new Options())->set(Option::PAGE_SIZE_BYTES, 8)->set(
+                Option::PAGE_SIZE_CHECK_INTERVAL,
+                2,
+            )),
+            Schema::with($id = FlatColumn::int64('id'), $name = FlatColumn::string('name')),
+            array_map(
+                static fn(int $i): array => ['id' => $i, 'name' => ($i % 3) === 0 ? null : 'n' . $i],
+                range(0, 5),
+            ),
+        );
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+
+        static::assertEquals(
+            new ColumnIndex(
+                [false, false, false],
+                [pack('P', 0), pack('P', 2), pack('P', 4)],
+                [pack('P', 1), pack('P', 3), pack('P', 5)],
+                BoundaryOrder::ASCENDING,
+                [0, 0, 0],
+            ),
+            $file->indexes()->columnIndex(0, $id),
+        );
+        static::assertEquals(
+            new ColumnIndex(
+                [false, false, false],
+                ['n1', 'n2', 'n4'],
+                ['n1', 'n2', 'n5'],
+                BoundaryOrder::ASCENDING,
+                [1, 1, 0],
+            ),
+            $file->indexes()->columnIndex(0, $name),
+        );
+        static::assertSame(
+            [0, 2, 4],
+            array_map(
+                static fn(PageLocation $page): int => $page->firstRowIndex,
+                $file->indexes()->offsetIndex(0, $name)->pages ?? [],
+            ),
+        );
+
+        if (extension_loaded('arrow')) {
+            static::assertSame(
+                iterator_to_array($file->values(), false),
+                iterator_to_array(
+                    MemoryParquetFile::read(new Reader(engine: new RustParquetEngine()), $bytes)->values(),
+                    false,
                 ),
-                'list_of_string' => array_map(static fn($i) => $faker->text(10), range(1, generate_random_int(2, 10))),
-            ],
-        ];
+            );
+        }
+    }
+
+    public function test_bloom_filters_are_written_after_each_row_group_for_the_columns_asked(): void
+    {
+        $bytes = MemoryParquetFile::written(Writer::php(options: (new Options())
+            ->set(Option::ROW_GROUP_SIZE_BYTES, 1)
+            ->set(Option::ROW_GROUP_SIZE_CHECK_INTERVAL, 3)
+            ->set(Option::PAGE_SIZE_BYTES, 1)
+            ->set(Option::PAGE_SIZE_CHECK_INTERVAL, 3)
+            ->set(Option::COLUMNS_BLOOM_FILTERS, [
+                'id' => new BloomFilterOptions(),
+            ])), Schema::with($id = FlatColumn::int64('id'), $name = FlatColumn::string('name')), array_map(static fn(int $i): array => ['id' => $i, 'name' => 'n' . $i], range(0, 5)));
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+
+        foreach ([[0, 1, 2], [3, 4, 5]] as $rowGroup => $ids) {
+            $chunks = $file->metadata()->rowGroups()->all()[$rowGroup]->columnChunks();
+            $bloomFilter = $file->indexes()->bloomFilter($rowGroup, $id);
+
+            static::assertNotNull($bloomFilter);
+            static::assertGreaterThan($chunks[1]->fileOffset(), $chunks[0]->bloomFilterOffset());
+
+            foreach ($ids as $value) {
+                static::assertTrue($bloomFilter->check((new BloomHash())->of($id, $value)));
+            }
+
+            static::assertNull($file->indexes()->bloomFilter($rowGroup, $name));
+        }
     }
 
-    private function createSchema(): Schema
+    public function test_both_engines_write_the_same_bloom_filter_bytes(): void
     {
-        return Schema::with(NestedColumn::struct('struct', [
-            FlatColumn::int64('int64'),
-            FlatColumn::boolean('boolean'),
-            FlatColumn::string('string'),
-            FlatColumn::int32('int32'),
-            NestedColumn::list('list_of_int', ListElement::int32()),
-            NestedColumn::list('list_of_string', ListElement::string()),
-        ]));
+        if (!extension_loaded('arrow')) {
+            static::markTestSkipped('arrow is not loaded');
+        }
+
+        $options = (new Options())->set(Option::COLUMNS_BLOOM_FILTERS, [
+            'id' => new BloomFilterOptions(0.05, 5000),
+            'name' => new BloomFilterOptions(0.01),
+        ]);
+        $schema = Schema::with($id = FlatColumn::int64('id'), $name = FlatColumn::string('name'));
+        $rows = array_map(static fn(int $i): array => ['id' => $i * 7, 'name' => 'n' . $i], range(0, 2999));
+        $php = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+            Writer::php(options: $options),
+            $schema,
+            $rows,
+        ));
+        $arrow = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+            new Writer(options: $options, engine: new RustParquetEngine()),
+            $schema,
+            $rows,
+        ));
+
+        foreach ([$id, $name] as $column) {
+            static::assertEquals($php->indexes()->bloomFilter(0, $column), $arrow->indexes()->bloomFilter(0, $column));
+        }
+    }
+
+    public function test_pages_of_a_list_column_start_at_row_boundaries(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+            Writer::php(options: (new Options())->set(Option::PAGE_SIZE_BYTES, 16)->set(
+                Option::PAGE_SIZE_CHECK_INTERVAL,
+                1,
+            )),
+            Schema::with($id = FlatColumn::int64('id'), NestedColumn::list('tags', ListElement::int64())),
+            array_map(static fn(int $i): array => ['id' => $i, 'tags' => range(0, $i % 4)], range(0, 19)),
+        ));
+        $element = $file->schema()->getFlat('tags.list.element');
+        $pages = $file->indexes()->offsetIndex(0, $element)->pages ?? [];
+        $firstRows = array_map(static fn(PageLocation $page): int => $page->firstRowIndex, $pages);
+        $ids = $file->indexes()->columnIndex(0, $id);
+
+        static::assertGreaterThan(1, count($pages));
+        static::assertSame($firstRows, array_values(array_unique($firstRows)));
+        static::assertSame($firstRows, array_map(
+            static fn(PageLocation $page): int => $page->firstRowIndex,
+            $file->indexes()->offsetIndex(0, $id)->pages ?? [],
+        ));
+        static::assertSame($firstRows, array_map(
+            static fn(string $min): int => unpack('P', $min)[1],
+            $ids->minValues ?? [],
+        ));
+    }
+
+    public function test_column_index_bounds_are_truncated_to_64_bytes(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+            Writer::php(),
+            Schema::with($name = FlatColumn::string('name')),
+            [['name' => str_repeat('a', 100)], ['name' => str_repeat('b', 100)]],
+        ));
+
+        static::assertSame([str_repeat('a', 64)], $file->indexes()->columnIndex(0, $name)?->minValues);
+        static::assertSame([str_repeat('b', 63) . 'c'], $file->indexes()->columnIndex(0, $name)?->maxValues);
+    }
+
+    public function test_the_statistics_level_decides_chunk_statistics_and_the_column_index(): void
+    {
+        $written =
+            static fn(StatisticsLevel $level): ParquetFile => MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+                Writer::php(options: (new Options())->set(Option::STATISTICS_LEVEL, $level)),
+                Schema::with(FlatColumn::int64('id')),
+                [['id' => 1], ['id' => 2]],
+            ));
+        $id = FlatColumn::int64('id');
+
+        foreach ([
+            [StatisticsLevel::NONE,  false, false],
+            [StatisticsLevel::CHUNK, true,  false],
+            [StatisticsLevel::PAGE,  true,  true],
+        ] as [$level, $chunk, $page]) {
+            $file = $written($level);
+
+            static::assertSame(
+                $chunk,
+                $file->metadata()->rowGroups()->all()[0]->columnChunks()[0]->statistics() !== null,
+            );
+            static::assertSame($page, $file->indexes()->columnIndex(0, $id) !== null);
+            static::assertNotNull($file->indexes()->offsetIndex(0, $id));
+        }
+    }
+
+    public function test_page_header_statistics_are_written_only_when_asked(): void
+    {
+        $headers = static fn(Options $options): array => array_map(
+            static fn(ColumnPageHeader $header) => $header->pageHeader->dataPageHeader()?->statistics(),
+            iterator_to_array(
+                MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+                    Writer::php(options: $options),
+                    Schema::with(FlatColumn::int64('id')),
+                    [['id' => 1], ['id' => 2]],
+                ))->pageHeaders(),
+                false,
+            ),
+        );
+
+        static::assertSame([null], $headers(new Options()));
+        static::assertSame(
+            2,
+            $headers((new Options())->set(Option::PAGE_HEADER_STATISTICS, true))[0]?->maxValue(FlatColumn::int64('id')),
+        );
+        static::assertSame(
+            [null],
+            $headers((new Options())->set(Option::PAGE_HEADER_STATISTICS, true)->set(
+                Option::STATISTICS_LEVEL,
+                StatisticsLevel::CHUNK,
+            )),
+        );
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/OptionsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/OptionsTest.php
index 7df6faac84..0e1ddd942c 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/OptionsTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/OptionsTest.php
@@ -4,10 +4,12 @@
 
 namespace Flow\Parquet\Tests\Integration;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\Writer\StatisticsLevel;
 use PHPUnit\Framework\TestCase;
 
 use function count;
@@ -208,4 +210,29 @@ public function test_set_empty_arrays(): void
         static::assertSame(0, count($columnsEncodings));
         static::assertTrue($options->has(Option::COLUMNS_ENCODINGS));
     }
+
+    public function test_an_enum_option_is_read_as_its_enum_class(): void
+    {
+        static::assertSame(StatisticsLevel::PAGE, (new Options())->getEnum(
+            Option::STATISTICS_LEVEL,
+            StatisticsLevel::class,
+        ));
+        static::assertSame(StatisticsLevel::NONE, (new Options())->set(
+            Option::STATISTICS_LEVEL,
+            StatisticsLevel::NONE,
+        )->getEnum(Option::STATISTICS_LEVEL, StatisticsLevel::class));
+    }
+
+    public function test_an_enum_option_of_another_class_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Option STATISTICS_LEVEL is not a Flow\\Parquet\\Writer\\StatisticsLevel, but: Flow\\Parquet\\ParquetFile\\Compressions',
+        );
+
+        (new Options())->set(Option::STATISTICS_LEVEL, Compressions::GZIP)->getEnum(
+            Option::STATISTICS_LEVEL,
+            StatisticsLevel::class,
+        );
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/ParquetFile/SchemaTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/ParquetFile/SchemaTest.php
index eb468d4b70..32e02c2207 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/ParquetFile/SchemaTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/ParquetFile/SchemaTest.php
@@ -11,11 +11,9 @@
 use Flow\Parquet\Dremel\Validator\ColumnDataValidator;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Data\DataConverter;
-use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
-use Flow\Parquet\ParquetFile\Schema\ListElement;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
-use Flow\Parquet\ParquetFile\Schema\Repetition;
+use Flow\Parquet\Tests\Context\DremelPaperDocuments;
 use PHPUnit\Framework\TestCase;
 
 use function iterator_to_array;
@@ -24,18 +22,16 @@ final class SchemaTest extends TestCase
 {
     public function test_dremel_paper_data_schema(): void
     {
-        $schema = $this->dremelPaperDataSchema();
+        $schema = DremelPaperDocuments::schema();
 
-        $rows = $this->dremelPaperDataStructure();
+        $rows = DremelPaperDocuments::rows();
         $shredder = new DremelShredder(
             new ColumnDataValidator(),
             $converter = DataConverter::initialize(Options::default()),
         );
         $assembler = new DremelAssembler($converter);
 
-        // @mago-ignore analysis:mixed-assignment
         foreach ($rows as $row) {
-            /** @var array<string, mixed> $row */
             static::assertIsArray($row);
             $shredResult = $shredder->shred($schema, [$row], 0);
 
@@ -73,79 +69,4 @@ public function test_dremel_paper_data_schema(): void
             }
         }
     }
-
-    private function dremelPaperDataSchema(): Schema
-    {
-        return Schema::with(
-            FlatColumn::int32('DocId', Repetition::REQUIRED),
-            NestedColumn::list('Links', ListElement::structure([
-                NestedColumn::list('Backward', ListElement::int32()),
-                NestedColumn::list('Forward', ListElement::int32()),
-            ])),
-            NestedColumn::list(
-                'Name',
-                ListElement::structure([
-                    NestedColumn::list(
-                        'Language',
-                        ListElement::structure([
-                            FlatColumn::string('Code', Repetition::REQUIRED),
-                            FlatColumn::string('Country'),
-                        ]),
-                        Repetition::OPTIONAL,
-                    ),
-                    FlatColumn::string('Url', Repetition::OPTIONAL),
-                ]),
-                Repetition::OPTIONAL,
-            ),
-        );
-    }
-
-    private function dremelPaperDataStructure(): array
-    {
-        return [
-            [
-                'DocId' => 10,
-                'Links' => [
-                    [
-                        'Forward' => [20, 40, 60],
-                        'Backward' => null,
-                    ],
-                ],
-                'Name' => [
-                    [
-                        'Url' => 'http://A',
-                        'Language' => [
-                            ['Code' => 'en-us', 'Country' => 'us'],
-                            ['Code' => 'en', 'Country' => null],
-                        ],
-                    ],
-                    [
-                        'Url' => 'http://B',
-                        'Language' => null,
-                    ],
-                    [
-                        'Url' => null,
-                        'Language' => [
-                            ['Code' => 'en-gb', 'Country' => 'gb'],
-                        ],
-                    ],
-                ],
-            ],
-            [
-                'DocId' => 20,
-                'Links' => [
-                    [
-                        'Backward' => [10, 30],
-                        'Forward' => [80],
-                    ],
-                ],
-                'Name' => [
-                    [
-                        'Url' => 'http://C',
-                        'Language' => null,
-                    ],
-                ],
-            ],
-        ];
-    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php
index cb4b7373b9..1fe024e5d9 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php
@@ -12,6 +12,7 @@
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\Writer\ColumnChunkBuilder\DeltaBinaryPackedColumnChunkBuilder;
+use Flow\Parquet\Writer\StatisticsOptions;
 use PHPUnit\Framework\TestCase;
 
 final class DeltaBinaryPackedColumnChunkBuilderTest extends TestCase
@@ -20,7 +21,12 @@ public function test_delta_encoding_with_negative_values(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('negative_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $negativeValues = [-10, -8, -6, -4, -2, 0, 2, 4, 6, 8];
 
@@ -42,7 +48,12 @@ public function test_delta_encoding_with_sequential_values(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('sequential_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $sequentialValues = range(1, 100);
 
@@ -64,7 +75,12 @@ public function test_delta_encoding_with_timestamp_sequence(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('timestamp_col', PhysicalType::INT64);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $baseTimestamp = 1609459200; // 2021-01-01 00:00:00
 
@@ -87,7 +103,12 @@ public function test_delta_encoding_workflow(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('workflow_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $values = range(1, 50);
 
@@ -113,7 +134,12 @@ public function test_round_trip_int32_sequential_values(): void
     {
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
@@ -136,7 +162,12 @@ public function test_round_trip_int64_timestamp_sequence(): void
     {
         $column = new FlatColumn('timestamp_col', PhysicalType::INT64);
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $baseTimestamp = 1609459200; // 2021-01-01 00:00:00
         $values = [];
@@ -161,7 +192,12 @@ public function test_round_trip_negative_values(): void
     {
         $column = new FlatColumn('negative_col', PhysicalType::INT32);
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $values = [-10, -8, -6, -4, -2, 0, 2, 4, 6, 8];
 
@@ -181,7 +217,12 @@ public function test_round_trip_with_different_compression(): void
     {
         $column = new FlatColumn('compressed_col', PhysicalType::INT32);
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::GZIP);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::GZIP,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $values = range(100, 200);
 
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php
new file mode 100644
index 0000000000..20ed597d87
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Integration/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Integration\Writer\ColumnChunkBuilder;
+
+use Flow\Parquet\Engine\PhpParquetEngine;
+use Flow\Parquet\Engine\RustParquetEngine;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\Page\ColumnPageHeader;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Mother\ParquetEngineMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function array_map;
+use function extension_loaded;
+use function iterator_to_array;
+
+final class RLEDictionaryChunkBuilderTest extends TestCase
+{
+    /**
+     * @param class-string $engine
+     */
+    #[TestWith([PhpParquetEngine::class])]
+    #[TestWith([RustParquetEngine::class])]
+    public function test_a_dictionary_column_over_many_pages_reads_back_exactly(string $engine): void
+    {
+        if ($engine === RustParquetEngine::class && !extension_loaded('arrow')) {
+            static::markTestSkipped('arrow is not loaded');
+        }
+
+        $values = ['a', 'b', 'c', 'd', 'a', 'e'];
+
+        static::assertSame($values, MemoryParquetFile::column(
+            new Reader(engine: ParquetEngineMother::create($engine)),
+            MemoryParquetFile::dictionaryColumn($values, new Options()),
+            's',
+        ));
+    }
+
+    /**
+     * @param class-string $engine
+     */
+    #[TestWith([PhpParquetEngine::class])]
+    #[TestWith([RustParquetEngine::class])]
+    public function test_pages_past_the_dictionary_page_size_are_written_plain(string $engine): void
+    {
+        if ($engine === RustParquetEngine::class && !extension_loaded('arrow')) {
+            static::markTestSkipped('arrow is not loaded');
+        }
+
+        $values = ['aaaa', 'bbbb', 'cccc', 'dddd', 'aaaa', 'eeee', null, 'ffff'];
+
+        static::assertSame($values, MemoryParquetFile::column(
+            new Reader(engine: ParquetEngineMother::create($engine)),
+            MemoryParquetFile::dictionaryColumn($values, (new Options())->set(Option::DICTIONARY_PAGE_SIZE, 16)),
+            's',
+        ));
+    }
+
+    public function test_the_chunk_lists_both_encodings_after_a_fallback_to_plain(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::dictionaryColumn(
+            ['aaaa', 'bbbb', 'cccc', 'dddd', 'eeee', 'ffff'],
+            (new Options())->set(Option::DICTIONARY_PAGE_SIZE, 32),
+        ));
+
+        static::assertEqualsCanonicalizing(
+            [Encodings::PLAIN, Encodings::RLE, Encodings::RLE_DICTIONARY],
+            $file->metadata()->rowGroups()->all()[0]->columnChunks()[0]->encodings(),
+        );
+        static::assertSame(
+            ['DICTIONARY_PAGE', 'RLE_DICTIONARY', 'RLE_DICTIONARY', 'PLAIN'],
+            array_map(
+                static fn(ColumnPageHeader $header): string => $header->pageHeader->type()->isDataPage()
+                    ? $header->pageHeader->dataPageHeader()?->encoding()->name ?? ''
+                    : $header->pageHeader->type()->name,
+                iterator_to_array($file->pageHeaders(), false),
+            ),
+        );
+    }
+
+    public function test_page_headers_list_the_dictionary_page_and_every_data_page(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::dictionaryColumn([
+            'a',
+            'b',
+            'c',
+            'd',
+            'a',
+            'e',
+        ], new Options()));
+
+        static::assertSame(
+            ['DICTIONARY_PAGE', 'DATA_PAGE', 'DATA_PAGE', 'DATA_PAGE'],
+            array_map(
+                static fn(ColumnPageHeader $header): string => $header->pageHeader->type()->name,
+                iterator_to_array($file->pageHeaders(), false),
+            ),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ColumnChunkMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ColumnChunkMother.php
new file mode 100644
index 0000000000..80857c7b7e
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ColumnChunkMother.php
@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\ParquetFile\Index\IndexLocation;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Statistics;
+
+final class ColumnChunkMother
+{
+    /**
+     * The chunk as old parquet-mr writes it (PARQUET-816): no dictionary page offset, the data page offset at the
+     * dictionary page.
+     */
+    public static function parquet816(ColumnChunk $chunk): ColumnChunk
+    {
+        $thrift = $chunk->toThrift();
+        $metadata = $thrift->meta_data ?? throw new InvalidArgumentException('No column metadata');
+        $metadata->data_page_offset = $chunk->pageOffset();
+        $metadata->dictionary_page_offset = null;
+
+        return ColumnChunk::fromThrift($thrift);
+    }
+
+    public static function withBloomFilter(FlatColumn $column, int $offset, ?int $length): ColumnChunk
+    {
+        return new ColumnChunk(
+            $column->type(),
+            Compressions::UNCOMPRESSED,
+            2,
+            4,
+            [$column->flatPath()],
+            [],
+            0,
+            0,
+            null,
+            4,
+            null,
+            null,
+            bloomFilterOffset: $offset,
+            bloomFilterLength: $length,
+        );
+    }
+
+    /**
+     * A chunk of two values of the column without statistics, its pages in bytes 4 to 24, its page indexes at the given
+     * locations.
+     */
+    public static function withIndexes(
+        FlatColumn $column,
+        ?IndexLocation $columnIndex,
+        ?IndexLocation $offsetIndex,
+    ): ColumnChunk {
+        return new ColumnChunk(
+            $column->type(),
+            Compressions::UNCOMPRESSED,
+            2,
+            4,
+            [$column->flatPath()],
+            [],
+            20,
+            20,
+            null,
+            4,
+            null,
+            null,
+            $columnIndex,
+            $offsetIndex,
+        );
+    }
+
+    /**
+     * A chunk of two values of the column, holding only its statistics.
+     */
+    public static function withStatistics(FlatColumn $column, ?Statistics $statistics): ColumnChunk
+    {
+        return new ColumnChunk(
+            $column->type(),
+            Compressions::UNCOMPRESSED,
+            2,
+            4,
+            [$column->flatPath()],
+            [],
+            0,
+            0,
+            null,
+            4,
+            null,
+            $statistics,
+        );
+    }
+
+    /**
+     * A chunk of the column whose pages take $bytes bytes from $offset.
+     */
+    public static function spanning(FlatColumn $column, int $offset, int $bytes): ColumnChunk
+    {
+        return new ColumnChunk(
+            $column->type(),
+            Compressions::UNCOMPRESSED,
+            2,
+            $offset,
+            [$column->flatPath()],
+            [],
+            $bytes,
+            $bytes,
+            null,
+            $offset,
+            null,
+            null,
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/FlatColumnMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/FlatColumnMother.php
new file mode 100644
index 0000000000..fc8b34809d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/FlatColumnMother.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Timestamp;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+
+final class FlatColumnMother
+{
+    public static function byteArrayDecimal(): FlatColumn
+    {
+        return new FlatColumn('d', PhysicalType::BYTE_ARRAY, ConvertedType::DECIMAL, LogicalType::decimal(2, 30));
+    }
+
+    public static function flbaDecimal(): FlatColumn
+    {
+        return new FlatColumn(
+            'd',
+            PhysicalType::FIXED_LEN_BYTE_ARRAY,
+            ConvertedType::DECIMAL,
+            LogicalType::decimal(2, 4),
+            typeLength: 2,
+        );
+    }
+
+    public static function float16(): FlatColumn
+    {
+        return new FlatColumn(
+            'f',
+            PhysicalType::FIXED_LEN_BYTE_ARRAY,
+            logicalType: new LogicalType(LogicalType::FLOAT16),
+            typeLength: 2,
+        );
+    }
+
+    public static function int64Decimal(): FlatColumn
+    {
+        return new FlatColumn('d', PhysicalType::INT64, ConvertedType::DECIMAL, LogicalType::decimal(2, 10));
+    }
+
+    public static function int96(): FlatColumn
+    {
+        return new FlatColumn('t', PhysicalType::INT96);
+    }
+
+    public static function interval(): FlatColumn
+    {
+        return new FlatColumn('i', PhysicalType::FIXED_LEN_BYTE_ARRAY, ConvertedType::INTERVAL, typeLength: 12);
+    }
+
+    public static function uint32(): FlatColumn
+    {
+        return new FlatColumn('u', PhysicalType::INT32, logicalType: LogicalType::integer(32, false));
+    }
+
+    public static function uint8(): FlatColumn
+    {
+        return new FlatColumn('u', PhysicalType::INT32, logicalType: LogicalType::integer(8, false));
+    }
+
+    public static function uint64(string $name = 'u'): FlatColumn
+    {
+        return new FlatColumn($name, PhysicalType::INT64, logicalType: LogicalType::integer(64, false));
+    }
+
+    public static function timestamp(TimeUnit $unit): FlatColumn
+    {
+        return new FlatColumn(
+            'ts',
+            PhysicalType::INT64,
+            logicalType: new LogicalType(LogicalType::TIMESTAMP, timestamp: new Timestamp(true, $unit)),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/FooterMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/FooterMother.php
new file mode 100644
index 0000000000..79c680d052
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/FooterMother.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\RowGroup;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Statistics;
+use Flow\Parquet\Tests\Double\SpyFooter;
+
+use function array_map;
+use function array_values;
+use function count;
+use function pack;
+
+final class FooterMother
+{
+    /**
+     * One row group of $rows rows, the columns' chunks without statistics, under TYPE_DEFINED_ORDER.
+     */
+    public static function oneGroup(int $rows, FlatColumn ...$columns): SpyFooter
+    {
+        return new SpyFooter(
+            Schema::with(...$columns),
+            $rows,
+            [new RowGroup(array_map(static fn(FlatColumn $column) => ColumnChunkMother::withStatistics(
+                $column,
+                null,
+            ), array_values($columns)), $rows)],
+            array_map(static fn(): ColumnOrder => ColumnOrder::TypeDefined, array_values($columns)),
+        );
+    }
+
+    /**
+     * An INT64 column `id` in row groups of two rows, one [min, max] per group, under TYPE_DEFINED_ORDER.
+     *
+     * @param array{int, int} ...$bounds
+     */
+    public static function idGroups(array ...$bounds): SpyFooter
+    {
+        $id = FlatColumn::int64('id');
+
+        return new SpyFooter(
+            Schema::with($id),
+            2 * count($bounds),
+            array_map(
+                static fn(array $bound): RowGroup => new RowGroup([
+                    ColumnChunkMother::withStatistics(
+                        $id,
+                        new Statistics(null, null, 0, null, pack('P', $bound[1]), pack('P', $bound[0])),
+                    ),
+                ], 2),
+                array_values($bounds),
+            ),
+            [ColumnOrder::TypeDefined],
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/OperatorMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/OperatorMother.php
new file mode 100644
index 0000000000..ae6e68e04a
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/OperatorMother.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Operator;
+
+final class OperatorMother
+{
+    public static function named(string $name): Operator
+    {
+        foreach (Operator::cases() as $operator) {
+            if ($operator->name === $name) {
+                return $operator;
+            }
+        }
+
+        throw new InvalidArgumentException('No operator ' . $name);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/PageContainerMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/PageContainerMother.php
new file mode 100644
index 0000000000..76407b8c7c
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/PageContainerMother.php
@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\Page\Header\DataPageHeader;
+use Flow\Parquet\ParquetFile\Page\Header\DataPageHeaderV2;
+use Flow\Parquet\ParquetFile\Page\Header\DictionaryPageHeader;
+use Flow\Parquet\ParquetFile\Page\Header\Type;
+use Flow\Parquet\ParquetFile\Page\PageHeader;
+use Flow\Parquet\Writer\PageContainer;
+
+use function strlen;
+
+final class PageContainerMother
+{
+    public static function dataPage(
+        int $valuesCount = 10,
+        string $pageBuffer = 'pagedata',
+        Encodings $encoding = Encodings::PLAIN,
+    ): PageContainer {
+        return new PageContainer(
+            $pageBuffer,
+            new PageHeader(
+                Type::DATA_PAGE,
+                strlen($pageBuffer),
+                strlen($pageBuffer),
+                dataPageHeader: new DataPageHeader(
+                    encoding: $encoding,
+                    repetitionLevelEncoding: Encodings::RLE,
+                    definitionLevelEncoding: Encodings::RLE,
+                    valuesCount: $valuesCount,
+                ),
+                dataPageHeaderV2: null,
+                dictionaryPageHeader: null,
+            ),
+        );
+    }
+
+    public static function dataPageV2(
+        int $valuesCount = 10,
+        string $pageBuffer = 'pagedata',
+        Encodings $encoding = Encodings::PLAIN,
+    ): PageContainer {
+        return new PageContainer(
+            $pageBuffer,
+            new PageHeader(
+                Type::DATA_PAGE_V2,
+                strlen($pageBuffer),
+                strlen($pageBuffer),
+                dataPageHeader: null,
+                dataPageHeaderV2: new DataPageHeaderV2(
+                    valuesCount: $valuesCount,
+                    nullsCount: 0,
+                    rowsCount: $valuesCount,
+                    encoding: $encoding,
+                    definitionsByteLength: 0,
+                    repetitionsByteLength: 0,
+                    isCompressed: false,
+                    statistics: null,
+                ),
+                dictionaryPageHeader: null,
+            ),
+        );
+    }
+
+    public static function dictionaryPage(
+        int $valuesCount = 5,
+        string $pageBuffer = 'dictdata',
+        Encodings $encoding = Encodings::RLE_DICTIONARY,
+    ): PageContainer {
+        return new PageContainer(
+            $pageBuffer,
+            new PageHeader(
+                Type::DICTIONARY_PAGE,
+                strlen($pageBuffer),
+                strlen($pageBuffer),
+                dataPageHeader: null,
+                dataPageHeaderV2: null,
+                dictionaryPageHeader: new DictionaryPageHeader(encoding: $encoding, valuesCount: $valuesCount),
+            ),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/PageIndexMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/PageIndexMother.php
new file mode 100644
index 0000000000..4d5e75ea5c
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/PageIndexMother.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
+
+use function array_fill;
+use function array_map;
+use function array_values;
+use function count;
+use function pack;
+
+final class PageIndexMother
+{
+    /**
+     * An INT64 column index, one [min, max] per page, null for a null page; no null in the other pages unless
+     * $nullCounts says so.
+     *
+     * @param list<null|array{int, int}> $bounds
+     * @param null|list<int> $nullCounts
+     */
+    public static function int64(array $bounds, ?array $nullCounts = null): ColumnIndex
+    {
+        return new ColumnIndex(
+            array_map(static fn(?array $bound): bool => $bound === null, $bounds),
+            array_map(static fn(?array $bound): string => $bound === null ? '' : pack('P', $bound[0]), $bounds),
+            array_map(static fn(?array $bound): string => $bound === null ? '' : pack('P', $bound[1]), $bounds),
+            BoundaryOrder::UNORDERED,
+            $nullCounts ?? array_fill(0, count($bounds), 0),
+        );
+    }
+
+    /**
+     * Pages starting at the given rows of the row group, 10 bytes each from byte 100.
+     */
+    public static function pagesAt(int ...$firstRows): OffsetIndex
+    {
+        $pages = [];
+
+        foreach (array_values($firstRows) as $page => $firstRow) {
+            $pages[] = new PageLocation(100 + (10 * $page), 10, $firstRow);
+        }
+
+        return new OffsetIndex($pages);
+    }
+
+    /**
+     * The consistent page index of a row group of $rows rows.
+     */
+    public static function consistent(ColumnIndex $columnIndex, OffsetIndex $offsetIndex, int $rows): PageIndex
+    {
+        return (
+            PageIndex::of($columnIndex, $offsetIndex, $rows) ?? throw new InvalidArgumentException(
+                'The column index and offset index are inconsistent',
+            )
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ReadPlanMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ReadPlanMother.php
new file mode 100644
index 0000000000..94ac20ff9b
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ReadPlanMother.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+
+final class ReadPlanMother
+{
+    /**
+     * The window over a file without page indexes.
+     */
+    public static function window(int $rows, int $offset = 0, ?int $limit = null): ReadPlan
+    {
+        return ReadPlan::window($rows, new InMemoryIndexes(), $offset, $limit);
+    }
+
+    /**
+     * By default every row read and none proven to match, so the row filter of $filter is evaluated on each.
+     */
+    public static function rowFiltered(
+        int $rows,
+        Filter $filter,
+        Schema $schema,
+        ?int $limit = null,
+        ?RowSelection $selection = null,
+        ?RowSelection $matched = null,
+    ): ReadPlan {
+        return new ReadPlan(
+            $selection ?? RowSelection::all($rows),
+            $matched ?? RowSelection::none($rows),
+            new InMemoryIndexes(),
+            BoundFilter::bind($filter, $schema, new Options())->rowFilter(),
+            $limit,
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/SbbfMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/SbbfMother.php
new file mode 100644
index 0000000000..5cc5c9a696
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/SbbfMother.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\BloomFilter\SbbfBuilder;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+
+final class SbbfMother
+{
+    /**
+     * A filter holding the physical values of the column.
+     */
+    public static function with(FlatColumn $column, bool|float|int|string ...$values): Sbbf
+    {
+        $builder = SbbfBuilder::for(new BloomFilterOptions(0.01, 100));
+
+        foreach ($values as $value) {
+            $builder->insert((new BloomHash())->of($column, $value));
+        }
+
+        return $builder->build();
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/StatisticsCounterMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/StatisticsCounterMother.php
new file mode 100644
index 0000000000..fd2ef3d7cb
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/StatisticsCounterMother.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Writer\StatisticsCounter;
+use Flow\Parquet\Writer\StatisticsTruncation;
+
+final class StatisticsCounterMother
+{
+    /**
+     * @param array<null|bool|float|int|string> $values
+     */
+    public static function counted(FlatColumn $column, array $values = [], int $truncateLength = 64): StatisticsCounter
+    {
+        $counter = new StatisticsCounter($column, new StatisticsTruncation($truncateLength));
+        $counter->addBatch($values);
+
+        return $counter;
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ZoneMapMother.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ZoneMapMother.php
new file mode 100644
index 0000000000..a71aa08020
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Mother/ZoneMapMother.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Mother;
+
+use Flow\Parquet\Filter\Evaluation\ZoneMap;
+
+use const NAN;
+
+final class ZoneMapMother
+{
+    /**
+     * Every value that is not null is NaN.
+     */
+    public static function allNaN(int $nullCount = 0): ZoneMap
+    {
+        return new ZoneMap(NAN, NAN, true, true, $nullCount, 10 - $nullCount, 10, true);
+    }
+
+    public static function allNull(int $rows = 10): ZoneMap
+    {
+        return new ZoneMap(null, null, true, true, $rows, null, $rows, false);
+    }
+
+    /**
+     * No null and, for a float column, no NaN.
+     */
+    public static function clean(bool|float|int|string $min, bool|float|int|string $max): ZoneMap
+    {
+        return new ZoneMap($min, $max, true, true, 0, 0, 10, false);
+    }
+
+    public static function inexact(string $min, string $max): ZoneMap
+    {
+        return new ZoneMap($min, $max, false, false, 0, 0, 10, false);
+    }
+
+    public static function ieee(float $min, float $max, int $nullCount = 0, ?int $nanCount = null): ZoneMap
+    {
+        return new ZoneMap($min, $max, true, true, $nullCount, $nanCount, 10, false);
+    }
+
+    public static function unknownNaN(float $min, float $max): ZoneMap
+    {
+        return new ZoneMap($min, $max, true, true, 0, null, 10, false);
+    }
+
+    public static function unknownNulls(bool|float|int|string $min, bool|float|int|string $max): ZoneMap
+    {
+        return new ZoneMap($min, $max, true, true, null, 0, 10, false);
+    }
+
+    public static function untrusted(int $nullCount = 0): ZoneMap
+    {
+        return new ZoneMap(null, null, true, true, $nullCount, null, 10, false);
+    }
+
+    public static function withNulls(
+        bool|float|int|string $min,
+        bool|float|int|string $max,
+        int $nullCount = 3,
+    ): ZoneMap {
+        return new ZoneMap($min, $max, true, true, $nullCount, 0, 10, false);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomFilterOptionsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomFilterOptionsTest.php
new file mode 100644
index 0000000000..19e1e1ea88
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomFilterOptionsTest.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\BloomFilter;
+
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use const NAN;
+
+final class BloomFilterOptionsTest extends TestCase
+{
+    public function test_defaults_are_arrow_rs_defaults(): void
+    {
+        $options = new BloomFilterOptions();
+
+        static::assertSame(0.05, $options->fpp);
+        static::assertNull($options->ndv);
+        static::assertSame(1_048_576, BloomFilterOptions::DEFAULT_NDV);
+    }
+
+    #[TestWith([0.0])]
+    #[TestWith([1.0])]
+    #[TestWith([-0.5])]
+    #[TestWith([NAN])]
+    public function test_a_false_positive_probability_outside_zero_and_one_is_refused(float $fpp): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A bloom filter false positive probability must be between 0 and 1');
+
+        new BloomFilterOptions($fpp);
+    }
+
+    public function test_an_ndv_below_one_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A bloom filter ndv must be at least 1, got 0');
+
+        new BloomFilterOptions(ndv: 0);
+    }
+
+    public function test_the_columns_option_is_read_by_flat_path_and_empty_when_unset(): void
+    {
+        $id = new BloomFilterOptions(0.01);
+
+        static::assertSame([], BloomFilterOptions::forColumns(new Options()));
+        static::assertSame(
+            ['id' => $id],
+            BloomFilterOptions::forColumns((new Options())->set(Option::COLUMNS_BLOOM_FILTERS, ['id' => $id])),
+        );
+    }
+
+    public function test_a_columns_option_value_that_is_not_bloom_filter_options_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Option COLUMNS_BLOOM_FILTERS takes BloomFilterOptions, got string for column "id"',
+        );
+
+        BloomFilterOptions::forColumns((new Options())->set(Option::COLUMNS_BLOOM_FILTERS, ['id' => 'fast']));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomFilterReaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomFilterReaderTest.php
new file mode 100644
index 0000000000..730eb73f19
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomFilterReaderTest.php
@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\BloomFilter;
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\BloomFilter\BloomFilterReader;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\BloomFilterBytes;
+use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use Flow\Parquet\Tests\Mother\SbbfMother;
+use Flow\Parquet\ThriftModel\BloomFilterAlgorithm;
+use Flow\Parquet\ThriftModel\BloomFilterCompression;
+use Flow\Parquet\ThriftModel\BloomFilterHash;
+use PHPUnit\Framework\TestCase;
+
+use function str_repeat;
+use function strlen;
+
+final class BloomFilterReaderTest extends TestCase
+{
+    public function test_a_filter_is_read_at_once_when_its_length_is_known(): void
+    {
+        $id = FlatColumn::int64('id');
+        $sbbf = SbbfMother::with($id, 7);
+        $bytes = $sbbf->serialized();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1' . $bytes));
+
+        static::assertEquals(
+            $sbbf,
+            (new BloomFilterReader($stream))->read(ColumnChunkMother::withBloomFilter($id, 4, strlen($bytes))),
+        );
+        static::assertSame(1, $stream->reads);
+    }
+
+    public function test_a_filter_of_unknown_length_reads_its_header_then_its_bitset(): void
+    {
+        $id = FlatColumn::int64('id');
+        $sbbf = SbbfMother::with($id, 7);
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1' . $sbbf->serialized()));
+
+        static::assertEquals(
+            $sbbf,
+            (new BloomFilterReader($stream))->read(ColumnChunkMother::withBloomFilter($id, 4, null)),
+        );
+        static::assertSame(2, $stream->reads);
+    }
+
+    public function test_a_length_no_filter_fits_in_is_an_unknown_length(): void
+    {
+        $id = FlatColumn::int64('id');
+        $sbbf = SbbfMother::with($id, 7);
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1' . $sbbf->serialized()));
+
+        static::assertEquals(
+            $sbbf,
+            (new BloomFilterReader($stream))->read(ColumnChunkMother::withBloomFilter($id, 4, 0)),
+        );
+        static::assertSame(2, $stream->reads);
+    }
+
+    public function test_a_header_declaring_no_bitset_is_refused(): void
+    {
+        $bytes = BloomFilterBytes::of('', 0);
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('The bloom filter at offset 4 declares 0 bytes');
+
+        (new BloomFilterReader(new MemorySourceStream('PAR1' . $bytes)))->read(ColumnChunkMother::withBloomFilter(
+            FlatColumn::int64('id'),
+            4,
+            strlen($bytes),
+        ));
+    }
+
+    public function test_a_chunk_without_a_filter_reads_nothing(): void
+    {
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1'));
+
+        static::assertNull((new BloomFilterReader($stream))->read(ColumnChunkMother::withStatistics(
+            FlatColumn::int64('id'),
+            null,
+        )));
+        static::assertSame(0, $stream->reads);
+    }
+
+    public function test_a_filter_of_an_unknown_algorithm_hash_or_compression_is_no_filter(): void
+    {
+        $id = FlatColumn::int64('id');
+        $bitset = str_repeat("\0", 32);
+
+        foreach ([
+            BloomFilterBytes::of($bitset, algorithm: new BloomFilterAlgorithm()),
+            BloomFilterBytes::of($bitset, hash: new BloomFilterHash()),
+            BloomFilterBytes::of($bitset, compression: new BloomFilterCompression()),
+        ] as $bytes) {
+            static::assertNull((new BloomFilterReader(new MemorySourceStream('PAR1'
+            . $bytes)))->read(ColumnChunkMother::withBloomFilter($id, 4, strlen($bytes))));
+        }
+    }
+
+    public function test_an_offset_no_filter_can_be_read_from_is_no_filter(): void
+    {
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1'));
+
+        static::assertNull((new BloomFilterReader($stream))->read(ColumnChunkMother::withBloomFilter(
+            FlatColumn::int64('id'),
+            -1,
+            40,
+        )));
+        static::assertSame(0, $stream->reads);
+    }
+
+    public function test_a_bitset_shorter_than_its_header_declares_is_refused(): void
+    {
+        $bytes = BloomFilterBytes::of(str_repeat("\0", 32), 64);
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('The bloom filter at offset 4 declares 64 bytes, 32 were read');
+
+        (new BloomFilterReader(new MemorySourceStream('PAR1' . $bytes)))->read(ColumnChunkMother::withBloomFilter(
+            FlatColumn::int64('id'),
+            4,
+            strlen($bytes),
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomHashTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomHashTest.php
new file mode 100644
index 0000000000..b483ed50cb
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/BloomHashTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\BloomFilter;
+
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use PHPUnit\Framework\TestCase;
+
+final class BloomHashTest extends TestCase
+{
+    public function test_byte_arrays_hash_without_their_length_prefix(): void
+    {
+        // xxh64 seed 0: "" = 0xef46db3751d8e999, "a" = 0xd24ec4f1a98c6e5b, "abc" = 0x44bc2cf5ad770999
+        static::assertSame(-1_205_034_819_632_174_695, (new BloomHash())->of(FlatColumn::string('s'), ''));
+        static::assertSame(-3_292_477_735_350_538_661, (new BloomHash())->of(FlatColumn::string('s'), 'a'));
+        static::assertSame(4_952_883_123_889_572_249, (new BloomHash())->of(FlatColumn::string('s'), 'abc'));
+    }
+
+    public function test_integers_hash_as_little_endian_bytes(): void
+    {
+        // xxh64("\x01\x00\x00\x00") = 0xf42f94001fcb5351, xxh64(8 x "\xff") = 0x85d136adb773c6c9
+        static::assertSame(-851_299_076_295_404_719, (new BloomHash())->of(FlatColumn::int32('i'), 1));
+        static::assertSame(-8_804_195_676_797_548_855, (new BloomHash())->of(FlatColumn::int64('l'), -1));
+    }
+
+    public function test_an_unsigned_64_bit_value_hashes_as_its_int64_bit_pattern(): void
+    {
+        static::assertSame(
+            (new BloomHash())->of(FlatColumn::int64('l'), -1),
+            (new BloomHash())->of(
+                new FlatColumn('u', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+                -1,
+            ),
+        );
+    }
+
+    public function test_floating_point_values_hash_as_little_endian_ieee_754(): void
+    {
+        // xxh64 of 1.5 as f32 = 0x4f2d82595c483a0d, as f64 = 0x49f7b96b6b5ccaf9
+        static::assertSame(5_705_359_623_260_224_013, (new BloomHash())->of(FlatColumn::float('f'), 1.5));
+        static::assertSame(5_329_932_555_030_153_977, (new BloomHash())->of(FlatColumn::double('d'), 1.5));
+    }
+
+    public function test_a_boolean_hashes_as_one_byte(): void
+    {
+        // xxh64("\x01") = 0x8a4127811b21e730
+        static::assertSame(-8_484_456_787_529_832_656, (new BloomHash())->of(FlatColumn::boolean('b'), true));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/SbbfBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/SbbfBuilderTest.php
new file mode 100644
index 0000000000..bad3c187f9
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/SbbfBuilderTest.php
@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\BloomFilter;
+
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\BloomFilter\SbbfBuilder;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use PHPUnit\Framework\TestCase;
+
+use function str_repeat;
+use function strlen;
+
+final class SbbfBuilderTest extends TestCase
+{
+    public function test_inserted_values_are_found_after_folding(): void
+    {
+        $builder = SbbfBuilder::for(new BloomFilterOptions(0.05, 1_048_576));
+
+        for ($id = 0; $id < 500; $id++) {
+            $builder->insert((new BloomHash())->of(FlatColumn::int64('id'), $id));
+        }
+
+        $sbbf = $builder->build();
+
+        for ($id = 0; $id < 500; $id++) {
+            static::assertTrue($sbbf->check((new BloomHash())->of(FlatColumn::int64('id'), $id)));
+        }
+    }
+
+    public function test_a_filter_too_full_to_fold_keeps_the_optimal_num_of_bytes(): void
+    {
+        // arrow-rs: -8 * 1000 / ln(1 - 0.01^(1/8)) = 9681 bits, 1210 bytes, rounded up to 2048
+        $builder = SbbfBuilder::for(new BloomFilterOptions(0.01, 1000));
+
+        for ($id = 0; $id < 2000; $id++) {
+            $builder->insert((new BloomHash())->of(FlatColumn::int64('id'), $id));
+        }
+
+        static::assertSame(
+            strlen(Sbbf::fromBytes(str_repeat("\0", 2048))->serialized()),
+            strlen($builder->build()->serialized()),
+        );
+    }
+
+    public function test_a_folded_filter_equals_one_built_at_its_size(): void
+    {
+        $folded = SbbfBuilder::for(new BloomFilterOptions(0.01, 1_048_576));
+        $fresh = SbbfBuilder::for(new BloomFilterOptions(0.01, 2000));
+
+        for ($id = 0; $id < 2000; $id++) {
+            $folded->insert((new BloomHash())->of(FlatColumn::int64('id'), $id));
+            $fresh->insert((new BloomHash())->of(FlatColumn::int64('id'), $id));
+        }
+
+        static::assertSame(
+            strlen(Sbbf::fromBytes(str_repeat("\0", 4096))->serialized()),
+            strlen($folded->build()->serialized()),
+        );
+        static::assertEquals($fresh->build(), $folded->build());
+    }
+
+    public function test_an_ndv_left_out_is_the_arrow_rs_default(): void
+    {
+        $default = SbbfBuilder::for(new BloomFilterOptions(0.01));
+        $explicit = SbbfBuilder::for(new BloomFilterOptions(0.01, BloomFilterOptions::DEFAULT_NDV));
+
+        for ($id = 0; $id < 2000; $id++) {
+            $default->insert((new BloomHash())->of(FlatColumn::int64('id'), $id));
+            $explicit->insert((new BloomHash())->of(FlatColumn::int64('id'), $id));
+        }
+
+        static::assertEquals($explicit->build(), $default->build());
+    }
+
+    public function test_an_empty_filter_folds_to_one_block(): void
+    {
+        static::assertEquals(
+            Sbbf::fromBytes(str_repeat("\0", Sbbf::BLOCK_BYTES)),
+            SbbfBuilder::for(new BloomFilterOptions(0.05, 1_048_576))->build(),
+        );
+    }
+
+    public function test_a_one_block_filter_is_not_folded(): void
+    {
+        $builder = SbbfBuilder::for(new BloomFilterOptions(0.05, 1));
+        $builder->insert(-1);
+
+        static::assertSame(
+            strlen(Sbbf::fromBytes(str_repeat("\0", Sbbf::BLOCK_BYTES))->serialized()),
+            strlen($builder->build()->serialized()),
+        );
+        static::assertTrue($builder->build()->check(-1));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/SbbfTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/SbbfTest.php
new file mode 100644
index 0000000000..20f7252f38
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/BloomFilter/SbbfTest.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\BloomFilter;
+
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\BloomFilter\Sbbf;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+use function str_repeat;
+
+final class SbbfTest extends TestCase
+{
+    public function test_a_parquet_mr_filter_holds_the_values_it_was_written_with(): void
+    {
+        $sbbf = Sbbf::fromBytes(pack(
+            'C*',
+            200,
+            1,
+            80,
+            20,
+            64,
+            68,
+            8,
+            109,
+            6,
+            37,
+            4,
+            67,
+            144,
+            80,
+            96,
+            32,
+            8,
+            132,
+            43,
+            33,
+            0,
+            5,
+            99,
+            65,
+            2,
+            0,
+            224,
+            44,
+            64,
+            78,
+            96,
+            4,
+        ));
+
+        for ($a = 0; $a < 10; $a++) {
+            static::assertTrue($sbbf->check((new BloomHash())->of(FlatColumn::string('a'), 'a' . $a)));
+        }
+    }
+
+    public function test_an_empty_filter_holds_nothing(): void
+    {
+        static::assertFalse(Sbbf::fromBytes(str_repeat("\0", 64))->check(-1));
+    }
+
+    public function test_the_bitset_is_serialized_after_its_header(): void
+    {
+        $bytes = str_repeat("\x01\x80", 32);
+
+        static::assertStringEndsWith($bytes, Sbbf::fromBytes($bytes)->serialized());
+    }
+
+    public function test_a_hash_with_the_top_bit_set_lands_in_the_block_and_bits_of_the_unsigned_formulas(): void
+    {
+        // u64 0xFFFFFFFFFFFFFFFF: block ((2^32 - 1) * 4) >> 32 = 3; word i's bit is the top 5 bits of 2^32 - SALT[i]
+        static::assertSame(
+            [
+                (3 * 256) + 23,
+                (3 * 256) + 32 + 23,
+                (3 * 256) + 64 + 14,
+                (3 * 256) + 96 + 11,
+                (3 * 256) + 128 + 17,
+                (3 * 256) + 160 + 26,
+                (3 * 256) + 192 + 12,
+                (3 * 256) + 224 + 20,
+            ],
+            Sbbf::bits(-1, 4),
+        );
+    }
+
+    /**
+     * @param non-negative-int $length
+     */
+    #[TestWith([0])]
+    #[TestWith([31])]
+    #[TestWith([33])]
+    public function test_a_bitset_of_no_whole_blocks_is_refused(int $length): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'A bloom filter bitset holds whole blocks of 32 bytes, got ' . $length . ' bytes',
+        );
+
+        Sbbf::fromBytes(str_repeat("\0", $length));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/DSL/FunctionsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/DSL/FunctionsTest.php
new file mode 100644
index 0000000000..8293b0cdf4
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/DSL/FunctionsTest.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\DSL;
+
+use Flow\Parquet\Filter\ColumnRef;
+use Flow\Parquet\Query;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+use function Flow\Parquet\DSL\parquet_query;
+
+final class FunctionsTest extends TestCase
+{
+    public function test_the_functions_build_the_nodes(): void
+    {
+        static::assertEquals(new ColumnRef('user.age'), parquet_column('user.age'));
+        static::assertEquals(new Query(), parquet_query());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PhysicalCodecTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PhysicalCodecTest.php
new file mode 100644
index 0000000000..fcd8249fad
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PhysicalCodecTest.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Data;
+
+use Flow\Parquet\Data\PhysicalCodec;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+use function str_repeat;
+use function var_export;
+
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+final class PhysicalCodecTest extends TestCase
+{
+    /**
+     * @return Generator<string, array{FlatColumn, bool|float|int|string, string}>
+     */
+    public static function values(): Generator
+    {
+        yield 'boolean true' => [FlatColumn::boolean('b'), true, "\x01"];
+        yield 'boolean false' => [FlatColumn::boolean('b'), false, "\x00"];
+        yield 'int32 negative' => [FlatColumn::int32('i'), -2, "\xfe\xff\xff\xff"];
+        yield 'int32 date' => [FlatColumn::date('d'), 19000, "\x38\x4a\x00\x00"];
+        yield 'int32 decimal unscaled' => [FlatColumn::decimal('d', 9, 2), -350, "\xa2\xfe\xff\xff"];
+        yield 'int64 min' => [FlatColumn::int64('i'), PHP_INT_MIN, "\x00\x00\x00\x00\x00\x00\x00\x80"];
+        yield 'int64 max' => [FlatColumn::int64('i'), PHP_INT_MAX, "\xff\xff\xff\xff\xff\xff\xff\x7f"];
+        yield 'int64 decimal unscaled' => [FlatColumn::decimal('d', 10, 2), -350, "\xa2\xfe\xff\xff\xff\xff\xff\xff"];
+        yield 'uint64 bit pattern' => [FlatColumnMother::uint64(), -1, "\xff\xff\xff\xff\xff\xff\xff\xff"];
+        yield 'float' => [FlatColumn::float('f'), 1.5, "\x00\x00\xc0\x3f"];
+        yield 'double negative zero' => [FlatColumn::double('d'), -0.0, "\x00\x00\x00\x00\x00\x00\x00\x80"];
+        yield 'string without length prefix' => [FlatColumn::string('s'), 'abc', 'abc'];
+        yield 'binary' => [new FlatColumn('b', PhysicalType::BYTE_ARRAY), "\x00\xff", "\x00\xff"];
+        yield 'byte array decimal unscaled bytes' => [FlatColumnMother::byteArrayDecimal(), "\xfe\xa2", "\xfe\xa2"];
+        yield 'flba decimal unscaled bytes' => [FlatColumnMother::flbaDecimal(), "\xfe\xa2", "\xfe\xa2"];
+        yield 'uuid bytes' => [FlatColumn::uuid('u'), str_repeat("\x01", 16), str_repeat("\x01", 16)];
+        yield 'int96 bytes' => [FlatColumnMother::int96(), str_repeat("\x02", 12), str_repeat("\x02", 12)];
+    }
+
+    #[DataProvider('values')]
+    public function test_round_trip(FlatColumn $column, bool|float|int|string $physical, string $bytes): void
+    {
+        $codec = new PhysicalCodec();
+
+        static::assertSame($bytes, $codec->encodeStatistic($column, $physical));
+        static::assertSame(var_export($physical, true), var_export($codec->decodeStatistic($column, $bytes), true));
+    }
+
+    public function test_a_statistic_of_the_wrong_width_decodes_to_null(): void
+    {
+        static::assertNull((new PhysicalCodec())->decodeStatistic(FlatColumn::int64('i'), "\x00\x00\x00\x00"));
+        static::assertNull((new PhysicalCodec())->decodeStatistic(FlatColumn::int32('i'), "\x00"));
+    }
+
+    public function test_encoding_a_value_of_the_wrong_type_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "i": string is not a INT64 physical value');
+
+        (new PhysicalCodec())->encodeStatistic(FlatColumn::int64('i'), '1');
+    }
+
+    public function test_float_accepts_an_int(): void
+    {
+        static::assertSame("\x00\x00\x00\x40", (new PhysicalCodec())->encodeStatistic(FlatColumn::float('f'), 2));
+        static::assertSame("\x00\x00\x00\x00\x00\x00\x00\x40", (new PhysicalCodec())->encodeStatistic(
+            FlatColumn::double('d'),
+            2,
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PhysicalOrderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PhysicalOrderTest.php
new file mode 100644
index 0000000000..ff5d7015f3
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PhysicalOrderTest.php
@@ -0,0 +1,211 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Data;
+
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+use function str_repeat;
+use function var_export;
+
+use const INF;
+use const NAN;
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+final class PhysicalOrderTest extends TestCase
+{
+    /**
+     * @return Generator<string, array{FlatColumn, bool|float|int|string, bool|float|int|string, int}>
+     */
+    public static function comparisons(): Generator
+    {
+        yield 'boolean false < true' => [FlatColumn::boolean('b'), false, true, -1];
+        yield 'boolean equal' => [FlatColumn::boolean('b'), true, true, 0];
+        yield 'int32 signed' => [FlatColumn::int32('i'), -1, 1, -1];
+        yield 'int64 signed' => [FlatColumn::int64('i'), PHP_INT_MIN, PHP_INT_MAX, -1];
+        yield 'date signed' => [FlatColumn::date('d'), -10, 3, -1];
+        yield 'uint32 bit pattern above int32 max' => [FlatColumnMother::uint32(), -294967296, 5, 1];
+        yield 'uint32 widened value equals its bit pattern' => [FlatColumnMother::uint32(), 4000000000, -294967296, 0];
+        yield 'uint64 -1 above PHP_INT_MAX' => [FlatColumnMother::uint64(), -1, PHP_INT_MAX, 1];
+        yield 'uint64 PHP_INT_MIN above PHP_INT_MAX' => [FlatColumnMother::uint64(), PHP_INT_MIN, PHP_INT_MAX, 1];
+        yield 'uint64 -1 above 5' => [FlatColumnMother::uint64(), -1, 5, 1];
+        yield 'uint64 small values' => [FlatColumnMother::uint64(), 3, 5, -1];
+        yield 'int64 decimal signed' => [FlatColumnMother::int64Decimal(), -350, 120, -1];
+        yield 'double -0.0 < +0.0' => [FlatColumn::double('f'), -0.0, 0.0, -1];
+        yield 'double NaN greatest' => [FlatColumn::double('f'), NAN, INF, 1];
+        yield 'double -inf smallest' => [FlatColumn::double('f'), -INF, -1.0e308, -1];
+        yield 'double negatives' => [FlatColumn::double('f'), -2.5, -1.5, -1];
+        yield 'float -0.0 < +0.0' => [FlatColumn::float('f'), -0.0, 0.0, -1];
+        yield 'float NaN greatest' => [FlatColumn::float('f'), NAN, INF, 1];
+        yield 'float equal' => [FlatColumn::float('f'), 1.5, 1.5, 0];
+        yield 'string bytes unsigned' => [FlatColumn::string('s'), '10', '9', -1];
+        yield 'string high byte above ascii' => [FlatColumn::string('s'), "\xff", 'a', 1];
+        yield 'string prefix shorter' => [FlatColumn::string('s'), 'ab', 'abc', -1];
+        yield 'binary equal' => [new FlatColumn('b', PhysicalType::BYTE_ARRAY), "\x00\x01", "\x00\x01", 0];
+        yield 'flba bytes unsigned' => [FlatColumn::fixedSizeByteArray('f', 2), "\x80\x00", "\x7f\xff", 1];
+        yield 'flba decimal negative < positive' => [FlatColumnMother::flbaDecimal(), "\xfe\xa2", "\x00\x78", -1];
+        yield 'flba decimal negatives' => [FlatColumnMother::flbaDecimal(), "\xff\x00", "\xff\x80", -1];
+        yield 'byte array decimal sign-extended equal' => [FlatColumnMother::byteArrayDecimal(), "\xff\x80", "\x80", 0];
+        yield 'byte array decimal longer positive is greater' => [
+            FlatColumnMother::byteArrayDecimal(),
+            "\x01\x00",
+            "\x7f",
+            1,
+        ];
+        yield 'byte array decimal longer negative is smaller' => [
+            FlatColumnMother::byteArrayDecimal(),
+            "\xfe\x00",
+            "\x80",
+            -1,
+        ];
+        yield 'byte array decimal zero-extended equal' => [FlatColumnMother::byteArrayDecimal(), "\x00\x05", "\x05", 0];
+        yield 'byte array decimal empty below value' => [FlatColumnMother::byteArrayDecimal(), '', "\x00", -1];
+        yield 'byte array decimal longer than the key width' => [
+            FlatColumnMother::byteArrayDecimal(),
+            str_repeat("\xff", 40) . "\x80",
+            "\x80",
+            0,
+        ];
+        yield 'byte array decimal longer than the key width below' => [
+            FlatColumnMother::byteArrayDecimal(),
+            str_repeat("\xff", 40) . "\x7f",
+            "\xff",
+            -1,
+        ];
+        yield 'float16 -0.0 < +0.0' => [FlatColumnMother::float16(), "\x00\x80", "\x00\x00", -1];
+        yield 'float16 negatives' => [FlatColumnMother::float16(), "\x00\xc0", "\x00\xbc", -1];
+        yield 'float16 NaN greatest' => [FlatColumnMother::float16(), "\x00\x7e", "\x00\x7c", 1];
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, bool|float|int|string, bool, bool}>
+     */
+    public static function nan_and_zero(): Generator
+    {
+        yield 'double NaN' => [FlatColumn::double('d'), NAN, true, false];
+        yield 'double +0.0' => [FlatColumn::double('d'), 0.0, false, true];
+        yield 'double -0.0' => [FlatColumn::double('d'), -0.0, false, true];
+        yield 'double 1.5' => [FlatColumn::double('d'), 1.5, false, false];
+        yield 'float NaN' => [FlatColumn::float('f'), NAN, true, false];
+        yield 'float16 NaN' => [FlatColumnMother::float16(), "\x00\x7e", true, false];
+        yield 'float16 negative NaN' => [FlatColumnMother::float16(), "\x00\xfe", true, false];
+        yield 'float16 infinity' => [FlatColumnMother::float16(), "\x00\x7c", false, false];
+        yield 'float16 +0' => [FlatColumnMother::float16(), "\x00\x00", false, true];
+        yield 'float16 -0' => [FlatColumnMother::float16(), "\x00\x80", false, true];
+        yield 'float16 1.0' => [FlatColumnMother::float16(), "\x00\x3c", false, false];
+        yield 'int64 zero' => [FlatColumn::int64('i'), 0, false, false];
+        yield 'string zero bytes' => [FlatColumn::string('s'), "\x00\x00", false, false];
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, bool}>
+     */
+    public static function floating_point(): Generator
+    {
+        yield 'float' => [FlatColumn::float('f'), true];
+        yield 'double' => [FlatColumn::double('d'), true];
+        yield 'float16' => [FlatColumnMother::float16(), true];
+        yield 'int32' => [FlatColumn::int32('i'), false];
+        yield 'flba decimal' => [FlatColumnMother::flbaDecimal(), false];
+        yield 'string' => [FlatColumn::string('s'), false];
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, bool}>
+     */
+    public static function signed(): Generator
+    {
+        yield 'int32' => [FlatColumn::int32('i'), true];
+        yield 'int64' => [FlatColumn::int64('i'), true];
+        yield 'date' => [FlatColumn::date('d'), true];
+        yield 'timestamp' => [FlatColumn::dateTime('t'), true];
+        yield 'int64 decimal' => [FlatColumnMother::int64Decimal(), true];
+        yield 'flba decimal' => [FlatColumnMother::flbaDecimal(), true];
+        yield 'uint32' => [FlatColumnMother::uint32(), false];
+        yield 'uint64' => [FlatColumnMother::uint64(), false];
+        yield 'boolean' => [FlatColumn::boolean('b'), false];
+        yield 'double' => [FlatColumn::double('d'), false];
+        yield 'string' => [FlatColumn::string('s'), false];
+        yield 'int96' => [FlatColumnMother::int96(), false];
+        yield 'uint8' => [FlatColumnMother::uint8(), false];
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn}>
+     */
+    public static function unordered(): Generator
+    {
+        yield 'int96' => [FlatColumnMother::int96()];
+        yield 'interval' => [FlatColumnMother::interval()];
+    }
+
+    #[DataProvider('comparisons')]
+    public function test_compare(
+        FlatColumn $column,
+        bool|float|int|string $a,
+        bool|float|int|string $b,
+        int $expected,
+    ): void {
+        static::assertSame($expected, PhysicalOrder::forColumn($column)->compare($a, $b));
+        static::assertSame(-$expected, PhysicalOrder::forColumn($column)->compare($b, $a));
+    }
+
+    #[DataProvider('unordered')]
+    public function test_unordered_columns_have_no_order(FlatColumn $column): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('INT96 and INTERVAL have no physical order');
+
+        PhysicalOrder::forColumn($column)->compare("\x00", "\x01");
+    }
+
+    #[DataProvider('floating_point')]
+    public function test_is_floating_point(FlatColumn $column, bool $expected): void
+    {
+        static::assertSame($expected, PhysicalOrder::forColumn($column)->isFloatingPoint());
+    }
+
+    #[DataProvider('nan_and_zero')]
+    public function test_is_nan_and_is_zero(
+        FlatColumn $column,
+        bool|float|int|string $value,
+        bool $nan,
+        bool $zero,
+    ): void {
+        $order = PhysicalOrder::forColumn($column);
+
+        static::assertSame($nan, $order->isNan($value));
+        static::assertSame($zero, $order->isZero($value));
+    }
+
+    public function test_signed_zeros(): void
+    {
+        static::assertSame('-0.0', var_export(PhysicalOrder::Double->zero(negative: true), true));
+        static::assertSame('0.0', var_export(PhysicalOrder::Float->zero(negative: false), true));
+        static::assertSame("\x00\x80", PhysicalOrder::Float16->zero(negative: true));
+        static::assertSame("\x00\x00", PhysicalOrder::Float16->zero(negative: false));
+    }
+
+    public function test_a_non_floating_point_order_has_no_signed_zero(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Signed has no signed zero');
+
+        PhysicalOrder::Signed->zero(negative: true);
+    }
+
+    #[DataProvider('signed')]
+    public function test_is_signed(FlatColumn $column, bool $expected): void
+    {
+        static::assertSame($expected, PhysicalOrder::forColumn($column)->isSigned());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValueUnpackerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValueUnpackerTest.php
index 3cccbbcd31..054b821a6b 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValueUnpackerTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValueUnpackerTest.php
@@ -135,21 +135,20 @@ public function test_unpack_double(): void
         static::assertEquals([1.123456789, 2.987654321], iterator_to_array($unpacker->unpack($column, 2)));
     }
 
-    public function test_unpack_fixed_len_byte_array_with_decimal_logical_type(): void
+    public function test_unpack_fixed_len_byte_array_with_decimal_logical_type_returns_unscaled_bytes(): void
     {
-        $column = FlatColumn::decimal('test_column', 10, 2);
+        $column = FlatColumn::decimal('test_column', 20, 2);
         $typeLength = $column->typeLength();
         static::assertNotNull($typeLength);
-        $buffer = encode_decimal(123.45, 10, 2, $typeLength);
-        $buffer .= encode_decimal(678.90, 10, 2, $typeLength);
-        $reader = new BinaryBufferReader($buffer);
+        $first = encode_decimal(123.45, 20, 2, $typeLength);
+        $second = encode_decimal(678.90, 20, 2, $typeLength);
 
-        $unpacker = new PlainValueUnpacker($reader);
+        $unpacker = new PlainValueUnpacker(new BinaryBufferReader($first . $second));
 
-        static::assertEquals([123.45, 678.90], iterator_to_array($unpacker->unpack($column, 2)));
+        static::assertSame([$first, $second], iterator_to_array($unpacker->unpack($column, 2)));
     }
 
-    public function test_unpack_byte_array_with_decimal_logical_type(): void
+    public function test_unpack_byte_array_with_decimal_logical_type_returns_unscaled_bytes(): void
     {
         $buffer =
             encode_u32(ByteOrder::LITTLE_ENDIAN, [3])
@@ -160,17 +159,20 @@ public function test_unpack_byte_array_with_decimal_logical_type(): void
 
         $unpacker = new PlainValueUnpacker(new BinaryBufferReader($buffer));
 
-        static::assertSame([12345.67, -12345.67], iterator_to_array($unpacker->unpack($column, 2)));
+        static::assertSame(["\x12\xD6\x87", "\xED\x29\x79"], iterator_to_array($unpacker->unpack($column, 2)));
     }
 
-    public function test_unpack_fixed_len_byte_array_with_negative_decimal(): void
+    public function test_unpack_fixed_len_byte_array_with_negative_decimal_returns_unscaled_bytes(): void
     {
         $unpacker = new PlainValueUnpacker(new BinaryBufferReader("\xFF\xED\x29\x79"));
-
-        static::assertSame(
-            [-12345.67],
-            iterator_to_array($unpacker->unpack(FlatColumn::decimal('test_column', 9, 2), 1)),
+        $column = new FlatColumn(
+            'test_column',
+            PhysicalType::FIXED_LEN_BYTE_ARRAY,
+            logicalType: LogicalType::decimal(2, 9),
+            typeLength: 4,
         );
+
+        static::assertSame(["\xFF\xED\x29\x79"], iterator_to_array($unpacker->unpack($column, 1)));
     }
 
     public function test_unpack_fixed_len_byte_array_with_null_logical_type_returns_raw_string(): void
@@ -218,7 +220,7 @@ public function test_unpack_fixed_len_byte_array_with_unsupported_logical_type_r
         static::assertEquals($data2, $result[1]);
     }
 
-    public function test_unpack_fixed_len_byte_array_with_uuid_logical_type(): void
+    public function test_unpack_fixed_len_byte_array_with_uuid_logical_type_returns_raw_bytes(): void
     {
         $uuid1 = (string) hex2bin('550e8400e29b41d4a716446655440000');
         $uuid2 = (string) hex2bin('6ba7b8109dad11d180b400c04fd430c8');
@@ -230,8 +232,8 @@ public function test_unpack_fixed_len_byte_array_with_uuid_logical_type(): void
 
         $result = iterator_to_array($unpacker->unpack($column, 2));
         static::assertCount(2, $result);
-        static::assertEquals('550e8400-e29b-41d4-a716-446655440000', $result[0]);
-        static::assertEquals('6ba7b810-9dad-11d1-80b4-00c04fd430c8', $result[1]);
+        static::assertSame($uuid1, $result[0]);
+        static::assertSame($uuid2, $result[1]);
     }
 
     public function test_unpack_float(): void
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValuesPackerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValuesPackerTest.php
index f84b3933d7..5c73a0ff50 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValuesPackerTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Data/PlainValuesPackerTest.php
@@ -8,6 +8,8 @@
 use Flow\Parquet\BinaryWriter\BinaryBufferWriter;
 use Flow\Parquet\Data\PlainValuesPacker;
 use Flow\Parquet\Data\PlainValueUnpacker;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\Converter\DecimalConverter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\LogicalType\Time;
@@ -23,14 +25,19 @@ final class PlainValuesPackerTest extends TestCase
     public function test_byte_array_decimal_round_trip(): void
     {
         $column = new FlatColumn('d', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::decimal(2, 9));
+        $converter = DecimalConverter::forColumn($column, Options::default());
+        static::assertNotNull($converter);
+        $physical = [$converter->toParquetType(12345.67), $converter->toParquetType(-12345.67)];
 
         $buffer = '';
-        (new PlainValuesPacker(new BinaryBufferWriter($buffer)))->packValues($column, [12345.67, -12345.67]);
+        (new PlainValuesPacker(new BinaryBufferWriter($buffer)))->packValues($column, $physical);
+        $unpacked = iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($buffer)))->unpack($column, 2));
 
-        static::assertSame(
-            [12345.67, -12345.67],
-            iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($buffer)))->unpack($column, 2)),
-        );
+        static::assertSame(["\x12\xD6\x87", "\xED\x29\x79"], $unpacked);
+        static::assertSame([12345.67, -12345.67], [
+            $converter->fromParquetType($unpacked[0]),
+            $converter->fromParquetType($unpacked[1]),
+        ]);
     }
 
     public function test_fixed_len_byte_array_decimal_above_int64_round_trip(): void
@@ -43,17 +50,19 @@ public function test_fixed_len_byte_array_decimal_above_int64_round_trip(): void
             Repetition::OPTIONAL,
             typeLength: 21,
         );
+        $converter = DecimalConverter::forColumn($column, Options::default());
+        static::assertNotNull($converter);
+        $physical = [$converter->toParquetType(1.2345678901234568E+39), $converter->toParquetType(-12345.67)];
 
         $buffer = '';
-        (new PlainValuesPacker(new BinaryBufferWriter($buffer)))->packValues($column, [
-            1.2345678901234568E+39,
-            -12345.67,
-        ]);
+        (new PlainValuesPacker(new BinaryBufferWriter($buffer)))->packValues($column, $physical);
+        $unpacked = iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($buffer)))->unpack($column, 2));
 
-        static::assertSame(
-            [1.2345678901234568E+39, -12345.67],
-            iterator_to_array((new PlainValueUnpacker(new BinaryBufferReader($buffer)))->unpack($column, 2)),
-        );
+        static::assertSame($physical, $unpacked);
+        static::assertSame([1.2345678901234568E+39, -12345.67], [
+            $converter->fromParquetType($unpacked[0]),
+            $converter->fromParquetType($unpacked[1]),
+        ]);
     }
 
     public function test_int32_decimal_round_trip(): void
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/DefinitionConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/DefinitionConverterTest.php
index ae53af1899..07c06b3bbe 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/DefinitionConverterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/DefinitionConverterTest.php
@@ -13,8 +13,6 @@
 
 final class DefinitionConverterTest extends TestCase
 {
-    private ?DefinitionConverter $definitionConverter = null;
-
     #[TestWith([0, null, new NullLevel(0)])]
     #[TestWith([1, null, new NullLevel(1), 'Value cannot be null for level "1" and max definition level "1"'])]
     #[TestWith([1, 'value', 'value'])]
@@ -26,9 +24,9 @@ public function test_optional(int $level, mixed $value, mixed $result, ?string $
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -53,9 +51,9 @@ public function test_optional_optional(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -79,9 +77,9 @@ public function test_optional_repeated_optional(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -113,9 +111,9 @@ public function test_optional_repeated_optional_repeated_optional(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -151,9 +149,9 @@ public function test_optional_repeated_optional_repeated_optional_repeated_optio
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -177,9 +175,9 @@ public function test_optional_repeated_required(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -202,9 +200,9 @@ public function test_optional_required(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -223,9 +221,9 @@ public function test_required(int $level, mixed $value, mixed $result, ?string $
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -247,9 +245,9 @@ public function test_required_optional(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -278,9 +276,9 @@ public function test_required_repeated_required_repeated_required(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
@@ -302,23 +300,13 @@ public function test_required_required(
 
         if ($exceptionMessage) {
             $this->expectExceptionMessage($exceptionMessage);
-            $this->definitionConverter()->toValue($repetitions, definitionLevel: $level, value: $value);
+            (new DefinitionConverter())->toValue($repetitions, definitionLevel: $level, value: $value);
         } else {
-            static::assertEquals($result, $this->definitionConverter()->toValue(
+            static::assertEquals($result, (new DefinitionConverter())->toValue(
                 $repetitions,
                 definitionLevel: $level,
                 value: $value,
             ));
         }
     }
-
-    private function definitionConverter(): DefinitionConverter
-    {
-        if ($this->definitionConverter) {
-            return $this->definitionConverter;
-        }
-        $this->definitionConverter = new DefinitionConverter();
-
-        return $this->definitionConverter;
-    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/ReadFlatColumnValuesTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/ReadFlatColumnValuesTest.php
index 6209908527..3707ab991b 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/ReadFlatColumnValuesTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/ColumnData/ReadFlatColumnValuesTest.php
@@ -5,14 +5,18 @@
 namespace Flow\Parquet\Tests\Unit\Dremel\ColumnData;
 
 use Flow\Parquet\Dremel\ColumnData\ReadFlatColumnValues;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
 use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
 use PHPUnit\Framework\TestCase;
 
 use function Flow\ETL\Adapter\Parquet\array_to_generator;
 use function Flow\Parquet\empty_generator;
+use function iterator_to_array;
 
 final class ReadFlatColumnValuesTest extends TestCase
 {
@@ -55,4 +59,36 @@ public function test_list(): void
 
         static::assertSame(2, $data->rowsCount());
     }
+
+    public function test_a_selection_keeps_the_levels_and_values_of_its_rows_only(): void
+    {
+        $leaf = Schema::with(NestedColumn::list('list', ListElement::int32()))->columnsFlat()[0];
+        $page = new ReadFlatColumnValues(
+            $leaf,
+            array_to_generator([1, 2, 3, 4, 5]),
+            repetitionLevels: [0, 1, 0, 0, 1, 1, 0],
+            definitionLevels: [3, 3, 1, 3, 3, 3, 0],
+        );
+
+        $selected = $page->select(
+            new RowSelection(new RowSelector(1, true), new RowSelector(2, false), new RowSelector(1, true)),
+        );
+
+        static::assertSame([0, 0, 1, 1], $selected->repetitionLevels());
+        static::assertSame([1, 3, 3, 3], $selected->definitionLevels());
+        static::assertSame([3, 4, 5], iterator_to_array($selected->rawValues(), false));
+    }
+
+    public function test_a_selection_over_another_row_count_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A selection of 2 rows cannot select from a page of 3 rows');
+
+        (new ReadFlatColumnValues(
+            FlatColumn::int32('int32'),
+            array_to_generator([1, 2, 3]),
+            repetitionLevels: [0, 0, 0],
+            definitionLevels: [1, 1, 1],
+        ))->select(RowSelection::all(2));
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/Validator/ColumnDataValidatorTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/Validator/ColumnDataValidatorTest.php
index b6a40192a8..c4f2aadcd8 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/Validator/ColumnDataValidatorTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Dremel/Validator/ColumnDataValidatorTest.php
@@ -67,7 +67,7 @@ public static function integers_out_of_range(): Generator
             '-32769 is out of the INT_16 range [-32768, 32767]',
         ];
         yield 'INT_32 above' => [
-            FlatColumn::int32('c'),
+            new FlatColumn('c', PhysicalType::INT32, ConvertedType::INT_32),
             4_000_000_000,
             '4000000000 is out of the INT_32 range [-2147483648, 2147483647]',
         ];
@@ -94,7 +94,7 @@ public static function integers_out_of_range(): Generator
         yield 'UINT_64 negative' => [
             new FlatColumn('c', PhysicalType::INT64, ConvertedType::UINT_64),
             -1,
-            '-1 is out of the UINT_64 range [0, 9223372036854775807]',
+            '-1 is out of the UINT_64 range [0, 18446744073709551615]',
         ];
         yield 'logical INTEGER(8, signed) above' => [
             new FlatColumn('c', PhysicalType::INT32, logicalType: LogicalType::integer(8, true)),
@@ -115,6 +115,58 @@ public function test_an_integer_out_of_the_column_range_is_refused_naming_its_ro
         (new ColumnDataValidator())->validate($column, $value, 3);
     }
 
+    /**
+     * @return Generator<string, array{FlatColumn, int|string}>
+     */
+    public static function uint64_values(): Generator
+    {
+        $converted = new FlatColumn('c', PhysicalType::INT64, ConvertedType::UINT_64);
+        $logical = new FlatColumn('c', PhysicalType::INT64, logicalType: LogicalType::integer(64, false));
+
+        yield 'int zero' => [$converted, 0];
+        yield 'digit string zero' => [$converted, '0'];
+        yield 'digit string above PHP_INT_MAX' => [$converted, '9223372036854775808'];
+        yield 'digit string max' => [$logical, '18446744073709551615'];
+    }
+
+    #[DataProvider('uint64_values')]
+    public function test_a_uint64_int_or_digit_string_is_accepted(FlatColumn $column, int|string $value): void
+    {
+        (new ColumnDataValidator())->validate($column, $value, 0);
+
+        $this->expectNotToPerformAssertions();
+    }
+
+    /**
+     * @return Generator<string, array{mixed, string}>
+     */
+    public static function not_uint64_values(): Generator
+    {
+        yield 'digit string above max' => ['18446744073709551616', '18446744073709551616'];
+        yield 'leading zero' => ['007', '007'];
+        yield 'not digits' => ['abc', 'abc'];
+        yield 'signed digit string' => ['-1', '-1'];
+        yield 'empty string' => ['', ''];
+        yield 'float' => [1.5, 'float'];
+    }
+
+    #[DataProvider('not_uint64_values')]
+    public function test_a_uint64_value_that_is_neither_int_nor_digit_string_is_refused(
+        mixed $value,
+        string $shown,
+    ): void {
+        $this->expectException(ValidationException::class);
+        $this->expectExceptionMessage(
+            'Column "c" row 2: ' . $shown . ' is out of the UINT_64 range [0, 18446744073709551615]',
+        );
+
+        (new ColumnDataValidator())->validate(
+            new FlatColumn('c', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            $value,
+            2,
+        );
+    }
+
     /**
      * @return Generator<string, array{mixed}>
      */
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/AdaptiveParquetEngineTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/AdaptiveParquetEngineTest.php
index cea7cd486b..956f7f8a44 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/AdaptiveParquetEngineTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/AdaptiveParquetEngineTest.php
@@ -20,6 +20,7 @@
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\Tests\Context\MemoryParquetFile;
 use Flow\Parquet\Tests\Mother\ParquetFileWriterMother;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use PHPUnit\Framework\TestCase;
 
@@ -49,8 +50,7 @@ public function test_rows_written_through_the_contract_read_back(): void
                 $engine->openForRead($filesystem->readFrom(path('memory://out.parquet')))->readColumns(
                     ['id'],
                     10,
-                    null,
-                    null,
+                    ReadPlanMother::window(2),
                 ),
                 false,
             ),
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/OptionsConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/OptionsConverterTest.php
index 4d28e05175..e7281fd97a 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/OptionsConverterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/OptionsConverterTest.php
@@ -4,11 +4,14 @@
 
 namespace Flow\Parquet\Tests\Unit\Engine\Arrow;
 
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
 use Flow\Parquet\Engine\Arrow\OptionsConverter;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\Writer\StatisticsLevel;
 use PHPUnit\Framework\TestCase;
 
 final class OptionsConverterTest extends TestCase
@@ -35,24 +38,39 @@ public function test_engine_options_are_read_from_the_options(): void
         );
     }
 
-    public function test_arrow_batch_size_is_excluded_when_null(): void
+    public function test_page_maximum_rows_count_is_mapped(): void
     {
-        $options = new Options();
-        $options->set(Option::ARROW_BATCH_SIZE, null);
-
-        $result = OptionsConverter::toExtension($options);
-
-        static::assertArrayNotHasKey('BATCH_SIZE', $result);
+        static::assertSame(
+            50,
+            OptionsConverter::toExtension((new Options())->set(
+                Option::PAGE_MAXIMUM_ROWS_COUNT,
+                50,
+            ))['PAGE_MAXIMUM_ROWS_COUNT'],
+        );
     }
 
-    public function test_arrow_batch_size_is_included_when_set(): void
+    public function test_statistics_truncate_length_is_mapped(): void
     {
-        $options = new Options();
-        $options->set(Option::ARROW_BATCH_SIZE, 512);
-
-        $result = OptionsConverter::toExtension($options);
+        static::assertSame(
+            8,
+            OptionsConverter::toExtension((new Options())->set(
+                Option::STATISTICS_TRUNCATE_LENGTH,
+                8,
+            ))['STATISTICS_TRUNCATE_LENGTH'],
+        );
+    }
 
-        static::assertSame(512, $result['BATCH_SIZE']);
+    public function test_page_index_options_are_mapped_with_the_statistics_level_by_name(): void
+    {
+        $result = OptionsConverter::toExtension((new Options())->set(
+            Option::STATISTICS_LEVEL,
+            StatisticsLevel::CHUNK,
+        )->set(Option::COLUMN_INDEX_TRUNCATE_LENGTH, 16)->set(Option::PAGE_HEADER_STATISTICS, true));
+
+        static::assertSame('CHUNK', $result['STATISTICS_LEVEL']);
+        static::assertSame(16, $result['COLUMN_INDEX_TRUNCATE_LENGTH']);
+        static::assertTrue($result['PAGE_HEADER_STATISTICS']);
+        static::assertSame('PAGE', OptionsConverter::toExtension(new Options())['STATISTICS_LEVEL']);
     }
 
     public function test_columns_compressions_maps_enum_names(): void
@@ -81,6 +99,33 @@ public function test_columns_encodings_maps_enum_names(): void
         static::assertSame(['col_a' => 'PLAIN', 'col_b' => 'RLE_DICTIONARY'], $result['COLUMNS_ENCODINGS']);
     }
 
+    public function test_columns_bloom_filters_map_to_fpp_and_ndv(): void
+    {
+        $options = new Options();
+        $options->set(Option::COLUMNS_BLOOM_FILTERS, [
+            'id' => new BloomFilterOptions(0.01, 1000),
+            'user.name' => new BloomFilterOptions(),
+        ]);
+
+        static::assertSame(
+            ['id' => ['fpp' => 0.01, 'ndv' => 1000], 'user.name' => ['fpp' => 0.05, 'ndv' => null]],
+            OptionsConverter::toExtension($options)['COLUMNS_BLOOM_FILTERS'],
+        );
+    }
+
+    public function test_columns_bloom_filters_refuse_a_value_that_is_not_bloom_filter_options(): void
+    {
+        $options = new Options();
+        $options->set(Option::COLUMNS_BLOOM_FILTERS, ['id' => 0.01]);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Option COLUMNS_BLOOM_FILTERS takes BloomFilterOptions, got float for column "id"',
+        );
+
+        OptionsConverter::toExtension($options);
+    }
+
     public function test_custom_compression_levels(): void
     {
         $options = new Options();
@@ -99,7 +144,7 @@ public function test_default_options_produces_expected_keys(): void
     {
         $result = OptionsConverter::toExtension(new Options());
 
-        static::assertArrayHasKey('BATCH_SIZE', $result);
+        static::assertArrayHasKey('STATISTICS_TRUNCATE_LENGTH', $result);
         static::assertArrayHasKey('GZIP_COMPRESSION_LEVEL', $result);
         static::assertArrayHasKey('BROTLI_COMPRESSION_LEVEL', $result);
         static::assertArrayHasKey('ZSTD_COMPRESSION_LEVEL', $result);
@@ -109,5 +154,6 @@ public function test_default_options_produces_expected_keys(): void
         static::assertArrayHasKey('WRITER_VERSION', $result);
         static::assertArrayNotHasKey('COLUMNS_COMPRESSIONS', $result);
         static::assertArrayNotHasKey('COLUMNS_ENCODINGS', $result);
+        static::assertArrayNotHasKey('COLUMNS_BLOOM_FILTERS', $result);
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/ReadPlanConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/ReadPlanConverterTest.php
new file mode 100644
index 0000000000..046f65b5d4
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/ReadPlanConverterTest.php
@@ -0,0 +1,198 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine\Arrow;
+
+use DateTimeImmutable;
+use Flow\Parquet\Engine\Arrow\ReadPlanConverter;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class ReadPlanConverterTest extends TestCase
+{
+    /**
+     * @return iterable<string, array{Filter, array<string, mixed>}>
+     */
+    public static function filters(): iterable
+    {
+        yield 'equal' => [
+            parquet_column('id')->equals(3),
+            [
+                'leaf' => 'intervals',
+                'path' => ['id'],
+                'intervals' => [[3, true, 3, true]],
+            ],
+        ];
+        yield 'less than, unbounded below' => [
+            parquet_column('id')->lessThan(3),
+            [
+                'leaf' => 'intervals',
+                'path' => ['id'],
+                'intervals' => [[null, false, 3, false]],
+            ],
+        ];
+        yield 'in, one interval per value' => [
+            parquet_column('id')->in([1, 5]),
+            [
+                'leaf' => 'intervals',
+                'path' => ['id'],
+                'intervals' => [[1, true, 1, true], [5, true, 5, true]],
+            ],
+        ];
+        yield 'empty in' => [
+            parquet_column('id')->in([]),
+            [
+                'leaf' => 'intervals',
+                'path' => ['id'],
+                'intervals' => [],
+            ],
+        ];
+        yield 'double, negative zero as zero' => [
+            parquet_column('score')->greaterThanOrEqual(-0.0),
+            [
+                'leaf' => 'intervals',
+                'path' => ['score'],
+                'intervals' => [[0.0, true, null, false]],
+            ],
+        ];
+        yield 'decimal as unscaled big-endian bytes' => [
+            parquet_column('d')->equals(12.34),
+            [
+                'leaf' => 'intervals',
+                'path' => ['d'],
+                'intervals' => [["\x00\x00\x00\x00\x00\x00\x04\xD2", true, "\x00\x00\x00\x00\x00\x00\x04\xD2", true]],
+            ],
+        ];
+        yield 'date as days' => [
+            parquet_column('day')->equals(new DateTimeImmutable('1970-01-03 00:00:00 UTC')),
+            [
+                'leaf' => 'intervals',
+                'path' => ['day'],
+                'intervals' => [[2, true, 2, true]],
+            ],
+        ];
+        yield 'struct leaf path' => [
+            parquet_column('address.city')->equals('a'),
+            [
+                'leaf' => 'intervals',
+                'path' => ['address', 'city'],
+                'intervals' => [['a', true, 'a', true]],
+            ],
+        ];
+        yield 'is null' => [parquet_column('id')->isNull(), ['leaf' => 'is_null', 'path' => ['id']]];
+        yield 'starts with' => [
+            parquet_column('address.city')->startsWith('ab'),
+            [
+                'leaf' => 'starts_with',
+                'path' => ['address', 'city'],
+                'prefix' => 'ab',
+            ],
+        ];
+        yield 'absent' => [parquet_column('missing')->equals(1), ['leaf' => 'absent', 'is_null' => false]];
+        yield 'is null on an absent column' => [
+            parquet_column('missing')->isNull(),
+            ['leaf' => 'absent', 'is_null' => true],
+        ];
+        yield 'nested not and or' => [
+            parquet_column('id')
+                ->isNull()
+                ->and(parquet_column('id')->isNull()->or(parquet_column('missing')->startsWith('a'))->negate()),
+            [
+                'and' => [
+                    ['leaf' => 'is_null', 'path' => ['id']],
+                    [
+                        'not' => [
+                            'or' => [['leaf' => 'is_null', 'path' => ['id']], ['leaf' => 'absent', 'is_null' => false]],
+                        ],
+                    ],
+                ],
+            ],
+        ];
+    }
+
+    #[DataProvider('filters')]
+    public function test_the_row_filter_crosses_as_a_tree_of_physical_leaves(Filter $filter, array $expected): void
+    {
+        static::assertSame(
+            ['selectors' => [[4, false]], 'filter' => $expected, 'limit' => null],
+            ReadPlanConverter::toExtension(ReadPlanMother::rowFiltered(
+                4,
+                $filter,
+                Schema::with(
+                    FlatColumn::int64('id'),
+                    FlatColumn::double('score'),
+                    FlatColumnMother::flbaDecimal(),
+                    FlatColumn::date('day'),
+                    NestedColumn::struct('address', [FlatColumn::string('city')]),
+                ),
+            )),
+        );
+    }
+
+    public function test_only_the_row_conjuncts_cross(): void
+    {
+        static::assertSame(
+            ['leaf' => 'is_null', 'path' => ['id']],
+            ReadPlanConverter::toExtension(ReadPlanMother::rowFiltered(
+                4,
+                parquet_column('id')->isNull()->and(parquet_column('id')->equals('x')),
+                Schema::with(FlatColumn::int64('id')),
+            ))['filter'] ?? null,
+        );
+    }
+
+    public function test_the_limit_crosses_beside_the_filter(): void
+    {
+        static::assertSame(
+            ['selectors' => [[4, false]], 'filter' => ['leaf' => 'is_null', 'path' => ['id']], 'limit' => 2],
+            ReadPlanConverter::toExtension(ReadPlanMother::rowFiltered(
+                4,
+                parquet_column('id')->isNull(),
+                Schema::with(FlatColumn::int64('id')),
+                2,
+            )),
+        );
+    }
+
+    public function test_a_row_filter_holding_a_leaf_not_answered_exactly_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Rows are evaluated on leaves answered exactly, the leaf on "id" is not');
+
+        ReadPlanConverter::toExtension(
+            new ReadPlan(
+                RowSelection::all(4),
+                RowSelection::none(4),
+                new InMemoryIndexes(),
+                BoundFilter::bind(
+                    parquet_column('id')->equals('1'),
+                    Schema::with(FlatColumn::int64('id')),
+                    new Options(),
+                ),
+            ),
+        );
+    }
+
+    public function test_the_selection_crosses_as_file_absolute_count_and_skip_pairs(): void
+    {
+        static::assertSame(
+            ['selectors' => [[2, true], [3, false]], 'limit' => null],
+            ReadPlanConverter::toExtension(ReadPlan::window(5, new InMemoryIndexes(), 2)),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/RustRowGroupChunksTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/RustRowGroupChunksTest.php
new file mode 100644
index 0000000000..4ba59c38ff
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/RustRowGroupChunksTest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine\Arrow;
+
+use Flow\Parquet\Engine\Arrow\RustRowGroupChunks;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Exception\OutOfBoundsException;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Context\ThriftBytes;
+use Flow\Parquet\ThriftModel\ColumnChunk as ThriftColumnChunk;
+use PHPUnit\Framework\TestCase;
+
+final class RustRowGroupChunksTest extends TestCase
+{
+    public function test_a_chunk_is_decoded_from_its_bytes_on_first_access_only(): void
+    {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata();
+        $id = $metadata->schema()->getFlat('id');
+        $chunks = RustRowGroupChunks::fromThrift(
+            [2, 2],
+            ['id' => [
+                ThriftBytes::of($metadata->rowGroups()->all()[0]->getColumnChunk($id)->toThrift()),
+                ThriftBytes::of(new ThriftColumnChunk(['file_offset' => 7])),
+            ]],
+            ['id' => ThriftBytes::of(ColumnOrder::TypeDefined->toThrift())],
+        );
+
+        static::assertSame([2, 2], $chunks->rowCounts());
+        static::assertEquals($metadata->rowGroups()->all()[0]->getColumnChunk($id), $chunks->chunk(0, $id));
+        static::assertSame($chunks->chunk(0, $id), $chunks->chunk(0, $id));
+        static::assertSame(ColumnOrder::TypeDefined, $chunks->columnOrder($id));
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Column chunk at offset 7 has no metadata (an encrypted column is not supported)',
+        );
+
+        $chunks->chunk(1, $id);
+    }
+
+    public function test_a_column_without_column_orders_has_an_absent_order(): void
+    {
+        static::assertSame(
+            ColumnOrder::Absent,
+            RustRowGroupChunks::fromThrift([], ['id' => []], ['id' => null])->columnOrder(FlatColumn::int64('id')),
+        );
+    }
+
+    public function test_a_column_that_was_not_read_from_the_footer_is_refused(): void
+    {
+        $chunks = RustRowGroupChunks::fromThrift([1], ['id' => ['']], ['id' => null]);
+
+        try {
+            $chunks->columnOrder(FlatColumn::int64('name'));
+            static::fail('An unknown column order must be refused');
+        } catch (InvalidArgumentException $exception) {
+            static::assertSame('Column "name" was not read from the footer', $exception->getMessage());
+        }
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "name" was not read from the footer');
+
+        $chunks->chunk(0, FlatColumn::int64('name'));
+    }
+
+    public function test_a_row_group_the_file_lacks_is_refused(): void
+    {
+        $chunks = RustRowGroupChunks::fromThrift([1], ['id' => ['']], ['id' => null]);
+
+        $this->expectException(OutOfBoundsException::class);
+        $this->expectExceptionMessage('Row group 1 does not exist');
+
+        $chunks->chunk(1, FlatColumn::int64('id'));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/SchemaConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/SchemaConverterTest.php
index bad365240a..81fde1756d 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/SchemaConverterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/Arrow/SchemaConverterTest.php
@@ -6,6 +6,7 @@
 
 use Flow\Parquet\Engine\Arrow\SchemaConverter;
 use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\ListElement;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
@@ -72,7 +73,14 @@ public function test_enum_column_to_extension(): void
         $schema = Schema::with(FlatColumn::enum('status'));
         $result = SchemaConverter::toExtension($schema);
 
-        static::assertSame('STRING', $result[0]['type']);
+        static::assertSame('ENUM', $result[0]['type']);
+    }
+
+    public function test_converted_only_enum_column_to_extension(): void
+    {
+        $schema = Schema::with(new FlatColumn('status', PhysicalType::BYTE_ARRAY, ConvertedType::ENUM));
+
+        static::assertSame('ENUM', SchemaConverter::toExtension($schema)[0]['type']);
     }
 
     public function test_fixed_size_byte_array_to_extension(): void
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/ArrowExtensionTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/ArrowExtensionTest.php
index ef894a0435..940384db0d 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/ArrowExtensionTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/ArrowExtensionTest.php
@@ -26,7 +26,7 @@ public function test_a_loaded_extension_of_another_abi_is_refused(): void
     {
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage(
-            'The loaded arrow extension (0.46.0, ABI 2) does not match flow-php/parquet (ABI 1). Rebuild or upgrade '
+            'The loaded arrow extension (0.46.0, ABI 3) does not match flow-php/parquet (ABI 2). Rebuild or upgrade '
             . 'arrow-ext to the version of flow-php/parquet, or stop loading it to use the PHP implementation.',
         );
 
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFileReaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFileReaderTest.php
index 7276cc8266..a22c32cd45 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFileReaderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFileReaderTest.php
@@ -10,84 +10,235 @@
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\Options;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
 use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
 use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
 use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
 use function array_column;
+use function Flow\Parquet\DSL\parquet_column;
 use function iterator_to_array;
 
 final class PhpParquetFileReaderTest extends TestCase
 {
-    public function test_the_footer_is_decoded_once(): void
+    public function test_the_footer_is_read_once(): void
     {
         $stream = new ReadCountingSourceStream(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
         $reader = new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options());
 
-        $metadata = $reader->metadata();
+        $footer = $reader->footer();
         $reads = $stream->reads;
 
-        static::assertSame($metadata, $reader->metadata());
-        static::assertSame($metadata->schema(), $reader->schema());
-        static::assertSame(6, $reader->rowsNumber());
+        static::assertSame($footer, $reader->footer());
+        static::assertSame(6, $footer->rowsNumber());
         static::assertSame($reads, $stream->reads);
     }
 
-    public function test_total_byte_size_sums_the_row_groups(): void
+    /**
+     * @param int<1, max> $batchSize
+     * @param list<list<int>> $ids
+     */
+    #[TestWith([4, 0, null, [[1, 2, 3, 4], [5, 6]]])]
+    #[TestWith([2, 2, 3, [[3, 4], [5]]])]
+    #[TestWith([2, 6, null, []])]
+    #[TestWith([2, 7, null, []])]
+    public function test_read_columns_chunks_the_rows(int $batchSize, int $offset, ?int $limit, array $ids): void
     {
         $reader = new PhpParquetFileReader(
             new MemorySourceStream(MemoryParquetFile::threeRowGroups()),
             ByteOrder::LITTLE_ENDIAN,
             new Options(),
         );
-        $expected = 0;
+        $chunks = iterator_to_array(
+            $reader->readColumns(['id'], $batchSize, ReadPlanMother::window(6, $offset, $limit)),
+            false,
+        );
 
-        foreach ($reader->metadata()->rowGroups()->all() as $rowGroup) {
-            $expected += $rowGroup->totalByteSize();
-        }
+        static::assertSame($ids, array_column($chunks, 'id'));
+    }
+
+    public function test_a_row_group_the_plan_skips_is_never_read(): void
+    {
+        $full = new ReadCountingSourceStream(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
+        $fullReader = new PhpParquetFileReader($full, ByteOrder::LITTLE_ENDIAN, new Options());
+        $id = $fullReader->footer()->schema()->getFlat('id');
+        iterator_to_array($fullReader->readColumns(['id'], 10, ReadPlanMother::window(6)), false);
+
+        $pruned = new ReadCountingSourceStream(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
+        $prunedReader = new PhpParquetFileReader($pruned, ByteOrder::LITTLE_ENDIAN, new Options());
+        $selection = new RowSelection(new RowSelector(2, false), new RowSelector(2, true), new RowSelector(2, false));
 
-        static::assertCount(3, $reader->metadata()->rowGroups()->all());
-        static::assertGreaterThan(0, $expected);
-        static::assertSame($expected, $reader->totalByteSize());
+        static::assertSame(
+            [[1, 2, 5, 6]],
+            array_column(
+                iterator_to_array(
+                    $prunedReader->readColumns(['id'], 10, new ReadPlan($selection, $selection, new InMemoryIndexes())),
+                    false,
+                ),
+                'id',
+            ),
+        );
+        static::assertSame(
+            $full->bytes
+            - $fullReader->footer()->metadata()->rowGroups()->all()[1]->getColumnChunk($id)->totalCompressedSize(),
+            $pruned->bytes,
+        );
     }
 
     /**
      * @param int<1, max> $batchSize
-     * @param list<list<int>> $ids
+     * @param list<list<mixed>> $values
      */
-    #[TestWith([4, null, null, [[1, 2, 3, 4], [5, 6]]])]
-    #[TestWith([2, 3, 2, [[3, 4], [5]]])]
-    #[TestWith([2, null, 6, []])]
-    #[TestWith([2, null, 7, []])]
-    public function test_read_columns_chunks_the_rows(int $batchSize, ?int $limit, ?int $offset, array $ids): void
+    #[TestWith(['id', 10, [[2, 3, 6]]])]
+    #[TestWith(['id', 2, [[2, 3], [6]]])]
+    #[TestWith(['tags', 1, [[['t2']], [['t3']], [['t6']]]])]
+    public function test_a_row_filter_returns_exactly_the_matching_rows_in_batches_across_row_groups(
+        string $column,
+        int $batchSize,
+        array $values,
+    ): void {
+        $reader = new PhpParquetFileReader(
+            new MemorySourceStream(MemoryParquetFile::threeRowGroups()),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        );
+
+        static::assertSame($values, array_column(
+            iterator_to_array(
+                $reader->readColumns(
+                    [$column],
+                    $batchSize,
+                    ReadPlanMother::rowFiltered(6, parquet_column('id')->in([2, 3, 6]), $reader->footer()->schema()),
+                ),
+                false,
+            ),
+            $column,
+        ));
+    }
+
+    public function test_a_limit_stops_the_read_inside_a_row_group_and_the_next_group_is_never_read(): void
+    {
+        $limited = new ReadCountingSourceStream(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
+        $limitedReader = new PhpParquetFileReader($limited, ByteOrder::LITTLE_ENDIAN, new Options());
+        $filter = parquet_column('id')->greaterThanOrEqual(2);
+
+        static::assertSame(
+            [[2, 3]],
+            array_column(
+                iterator_to_array(
+                    $limitedReader->readColumns(
+                        ['id'],
+                        10,
+                        ReadPlanMother::rowFiltered(6, $filter, $limitedReader->footer()->schema(), 2),
+                    ),
+                    false,
+                ),
+                'id',
+            ),
+        );
+
+        $twoGroups = new ReadCountingSourceStream(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
+        $twoGroupsReader = new PhpParquetFileReader($twoGroups, ByteOrder::LITTLE_ENDIAN, new Options());
+        iterator_to_array(
+            $twoGroupsReader->readColumns(
+                ['id'],
+                10,
+                ReadPlanMother::rowFiltered(
+                    6,
+                    $filter,
+                    $twoGroupsReader->footer()->schema(),
+                    selection: RowSelection::window(6, 0, 4),
+                ),
+            ),
+            false,
+        );
+
+        static::assertSame($twoGroups->bytes, $limited->bytes);
+    }
+
+    public function test_rows_proven_to_match_are_returned_without_evaluating_the_row_filter(): void
     {
         $reader = new PhpParquetFileReader(
             new MemorySourceStream(MemoryParquetFile::threeRowGroups()),
             ByteOrder::LITTLE_ENDIAN,
             new Options(),
         );
-        $chunks = iterator_to_array($reader->readColumns(['id'], $batchSize, $limit, $offset), false);
 
-        static::assertSame($ids, array_column($chunks, 'id'));
+        static::assertSame(
+            [[1, 2, 5, 6]],
+            array_column(
+                iterator_to_array(
+                    $reader->readColumns(
+                        ['id'],
+                        10,
+                        ReadPlanMother::rowFiltered(
+                            6,
+                            parquet_column('id')->greaterThan(4),
+                            $reader->footer()->schema(),
+                            matched: RowSelection::window(6, 0, 2),
+                        ),
+                    ),
+                    false,
+                ),
+                'id',
+            ),
+        );
+    }
+
+    public function test_a_limit_of_zero_or_no_column_reads_nothing(): void
+    {
+        $reader = new PhpParquetFileReader(
+            new MemorySourceStream(MemoryParquetFile::threeRowGroups()),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        );
+
+        static::assertSame(
+            [],
+            iterator_to_array(
+                $reader->readColumns(
+                    ['id'],
+                    10,
+                    ReadPlanMother::rowFiltered(6, parquet_column('id')->isNull(), $reader->footer()->schema(), 0),
+                ),
+                false,
+            ),
+        );
+        static::assertSame([], iterator_to_array($reader->readColumns([], 10, ReadPlanMother::window(6)), false));
+    }
+
+    public function test_a_plan_over_another_row_count_is_refused(): void
+    {
+        $reader = new PhpParquetFileReader(
+            new MemorySourceStream(MemoryParquetFile::threeRowGroups()),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A read plan over 5 rows cannot read a file of 6 rows');
+
+        iterator_to_array($reader->readColumns(['id'], 10, ReadPlanMother::window(5)));
     }
 
-    public function test_close_closes_the_stream_and_every_later_call_throws(): void
+    public function test_close_closes_the_stream_and_every_later_call_throws_but_a_taken_footer_stays_readable(): void
     {
         $stream = new ReadCountingSourceStream(new MemorySourceStream(MemoryParquetFile::threeRowGroups()));
         $reader = new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options());
-        $reader->metadata();
+        $footer = $reader->footer();
 
         $reader->close();
 
         static::assertTrue($stream->closed);
 
         foreach ([
-            static fn() => $reader->metadata(),
-            static fn() => $reader->schema(),
-            static fn() => $reader->rowsNumber(),
-            static fn() => $reader->totalByteSize(),
-            static fn() => iterator_to_array($reader->readColumns(['id'], 1, null, null)),
+            static fn() => $reader->footer(),
+            static fn() => iterator_to_array($reader->readColumns(['id'], 1, ReadPlanMother::window(6))),
             static fn() => $reader->close(),
         ] as $call) {
             try {
@@ -97,6 +248,7 @@ public function test_close_closes_the_stream_and_every_later_call_throws(): void
                 static::assertSame('Reader is not open', $exception->getMessage());
             }
         }
+        static::assertSame(6, $footer->rowsNumber());
     }
 
     public function test_a_file_without_the_parquet_magic_is_refused(): void
@@ -108,6 +260,6 @@ public function test_a_file_without_the_parquet_magic_is_refused(): void
             new MemorySourceStream('not a parquet file'),
             ByteOrder::LITTLE_ENDIAN,
             new Options(),
-        ))->metadata();
+        ))->footer();
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFooterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFooterTest.php
new file mode 100644
index 0000000000..f39c24db4d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/PhpParquetFooterTest.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Engine;
+
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use PHPUnit\Framework\TestCase;
+
+final class PhpParquetFooterTest extends TestCase
+{
+    public function test_the_metadata_is_built_once_and_answers_the_schema_and_row_count(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups());
+        $footer = $file->reader()->footer();
+
+        $metadata = $footer->metadata();
+
+        static::assertSame($metadata, $footer->metadata());
+        static::assertSame($metadata->schema(), $footer->schema());
+        static::assertSame(6, $footer->rowsNumber());
+    }
+
+    public function test_total_byte_size_sums_the_row_groups(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups());
+        $footer = $file->reader()->footer();
+        $expected = 0;
+
+        foreach ($footer->metadata()->rowGroups()->all() as $rowGroup) {
+            $expected += $rowGroup->totalByteSize();
+        }
+
+        static::assertCount(3, $footer->metadata()->rowGroups()->all());
+        static::assertGreaterThan(0, $expected);
+        static::assertSame($expected, $footer->totalByteSize());
+    }
+
+    public function test_row_group_chunks_answer_from_the_metadata(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups());
+        $footer = $file->reader()->footer();
+        $id = $footer->schema()->getFlat('id');
+        $chunks = $footer->rowGroupChunks([$id]);
+
+        static::assertSame([2, 2, 2], $chunks->rowCounts());
+        static::assertSame(3, $chunks->chunk(1, $id)->statistics()?->minValue($id));
+        static::assertSame($footer->metadata()->columnOrder($id), $chunks->columnOrder($id));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/RustParquetEngineTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/RustParquetEngineTest.php
index c9f906815f..b13556d257 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/RustParquetEngineTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Engine/RustParquetEngineTest.php
@@ -14,6 +14,7 @@
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 use PHPUnit\Framework\TestCase;
 
@@ -31,7 +32,11 @@ public function test_int96_as_datetime_false_refuses_an_int96_column(): void
         $this->expectExceptionMessage('Parquet column "ts" holds INT96');
 
         $engine->openForRead(NativeLocalSourceStream::open(path_real(__DIR__
-        . '/../../Integration/IO/Fixtures/EdgeCases/int96.parquet')))->readColumns(['ts'], 10, null, null);
+        . '/../../Integration/IO/Fixtures/EdgeCases/int96.parquet')))->readColumns(
+            ['ts'],
+            10,
+            ReadPlanMother::window(2),
+        );
     }
 
     public function test_lzo_is_refused(): void
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/AllTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/AllTest.php
new file mode 100644
index 0000000000..0b55a78594
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/AllTest.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class AllTest extends TestCase
+{
+    public function test_it_visits_as_its_kind(): void
+    {
+        $composite = new All(
+            parquet_column('a')->equals(1),
+            parquet_column('b')->isNull(),
+            parquet_column('a')->lessThan(3),
+        );
+
+        static::assertSame('all', $composite->accept(new NodeNameVisitor()));
+        static::assertCount(3, $composite->filters);
+    }
+
+    public function test_it_combines_and_negates(): void
+    {
+        $composite = new All(parquet_column('a')->equals(1));
+        $other = parquet_column('other')->isNull();
+
+        static::assertEquals(new All($composite, $other), $composite->and($other));
+        static::assertEquals(new Any($composite, $other), $composite->or($other));
+        static::assertEquals(new Not($composite), $composite->negate());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/AnyTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/AnyTest.php
new file mode 100644
index 0000000000..8c4ed4d133
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/AnyTest.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class AnyTest extends TestCase
+{
+    public function test_it_visits_as_its_kind(): void
+    {
+        $composite = new Any(
+            parquet_column('a')->equals(1),
+            parquet_column('b')->isNull(),
+            parquet_column('a')->lessThan(3),
+        );
+
+        static::assertSame('any', $composite->accept(new NodeNameVisitor()));
+        static::assertCount(3, $composite->filters);
+    }
+
+    public function test_it_combines_and_negates(): void
+    {
+        $composite = new Any(parquet_column('a')->equals(1));
+        $other = parquet_column('other')->isNull();
+
+        static::assertEquals(new All($composite, $other), $composite->and($other));
+        static::assertEquals(new Any($composite, $other), $composite->or($other));
+        static::assertEquals(new Not($composite), $composite->negate());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/BoundFilterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/BoundFilterTest.php
new file mode 100644
index 0000000000..5d0ab12bca
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/BoundFilterTest.php
@@ -0,0 +1,312 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding;
+
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Binding\AbsentLeaf;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Binding\PhysicalInterval;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Binding\RefusedLeaf;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use PHPUnit\Framework\TestCase;
+
+use function array_map;
+use function Flow\Parquet\DSL\parquet_column;
+
+final class BoundFilterTest extends TestCase
+{
+    public function test_each_leaf_resolves_to_its_column_with_its_pre_image(): void
+    {
+        $id = FlatColumn::int64('id');
+        $city = FlatColumn::string('city');
+        $schema = Schema::with($id, NestedColumn::struct('address', [$city]));
+        $equals = parquet_column('id')->equals(5);
+        $prefix = parquet_column('address.city')->startsWith('Wa');
+        $null = parquet_column('id')->isNull();
+        $set = parquet_column('id')->in([1]);
+        $bound = BoundFilter::bind(new All($equals, $prefix->or($null)->negate(), $set), $schema, new Options());
+
+        $equalsLeaf = $bound->leaf($equals);
+        $prefixLeaf = $bound->leaf($prefix);
+        $nullLeaf = $bound->leaf($null);
+        $setLeaf = $bound->leaf($set);
+
+        static::assertInstanceOf(ResolvedLeaf::class, $equalsLeaf);
+        static::assertInstanceOf(ResolvedLeaf::class, $prefixLeaf);
+        static::assertInstanceOf(ResolvedLeaf::class, $nullLeaf);
+        static::assertInstanceOf(ResolvedLeaf::class, $setLeaf);
+        static::assertEquals(
+            new PhysicalIntervals(PhysicalOrder::Signed, [new PhysicalInterval(5, true, 5, true)]),
+            $equalsLeaf->intervals,
+        );
+        static::assertEquals(
+            new PhysicalIntervals(PhysicalOrder::Bytes, [new PhysicalInterval('Wa', true, 'Wb', false)]),
+            $prefixLeaf->intervals,
+        );
+        static::assertEquals(new PhysicalIntervals(PhysicalOrder::Signed, []), $nullLeaf->intervals);
+        static::assertEquals(
+            new PhysicalIntervals(PhysicalOrder::Signed, [new PhysicalInterval(1, true, 1, true)]),
+            $setLeaf->intervals,
+        );
+        static::assertEquals([$schema->getFlat('id'), $schema->getFlat('address.city')], $bound->columns());
+        static::assertTrue($bound->answersEveryConjunct());
+    }
+
+    public function test_the_leaves_are_listed_depth_first(): void
+    {
+        $a = parquet_column('a')->equals(1);
+        $b = parquet_column('b')->equals(1);
+        $c = parquet_column('c')->isNull();
+        $d = parquet_column('d')->in([1]);
+
+        static::assertSame(
+            [$a, $b, $c, $d],
+            BoundFilter::bind(
+                new All($a, $b->or($c->negate()), $d),
+                Schema::with(FlatColumn::int64('a')),
+                new Options(),
+            )->leaves(),
+        );
+    }
+
+    public function test_a_column_the_file_lacks_is_absent(): void
+    {
+        $leaf = parquet_column('missing')->equals(1);
+        $bound = BoundFilter::bind($leaf, Schema::with(FlatColumn::int64('id')), new Options());
+
+        static::assertEquals(new AbsentLeaf(), $bound->leaf($leaf));
+        static::assertSame([], $bound->columns());
+        static::assertTrue($bound->answersEveryConjunct());
+    }
+
+    public function test_a_leaf_the_file_cannot_answer_exactly_leaves_rows_unfiltered_by_it(): void
+    {
+        $schema = Schema::with(
+            FlatColumn::int64('id'),
+            NestedColumn::list('tags', ListElement::string()),
+            NestedColumn::struct('address', [FlatColumn::string('city')]),
+            FlatColumnMother::byteArrayDecimal(),
+            FlatColumn::uuid('u'),
+            FlatColumnMother::uint64('big'),
+            FlatColumn::dateTime('ts'),
+            FlatColumn::boolean('flag'),
+            FlatColumn::json('doc'),
+        );
+        $leaves = [
+            parquet_column('id')->equals('1'),
+            parquet_column('tags.list.element')->equals('a'),
+            parquet_column('address')->isNull(),
+            parquet_column('id')->startsWith('1'),
+            parquet_column('d')->startsWith('1'),
+            parquet_column('u')->startsWith('1'),
+            parquet_column('big')->equals(' 9'),
+            parquet_column('big')->in(['1', '09']),
+            parquet_column('ts')->greaterThan('2024-01-01'),
+            parquet_column('flag')->equals(1),
+            parquet_column('doc')->equals('{}'),
+        ];
+        $bound = BoundFilter::bind(new All(...$leaves), $schema, new Options());
+
+        foreach ($leaves as $leaf) {
+            $resolution = $bound->leaf($leaf);
+
+            static::assertTrue(
+                $resolution instanceof RefusedLeaf
+                || $resolution instanceof ResolvedLeaf && $resolution->intervals === null,
+            );
+        }
+
+        static::assertSame([], $bound->columns());
+        static::assertNull($bound->rowFilter());
+        static::assertFalse($bound->answersEveryConjunct());
+    }
+
+    public function test_is_null_on_an_int96_column_is_evaluated_on_rows(): void
+    {
+        $null = parquet_column('t')->isNull();
+        $bound = BoundFilter::bind($null, Schema::with(FlatColumnMother::int96()), new Options());
+
+        static::assertInstanceOf(ResolvedLeaf::class, $bound->rowLeaf($null));
+        static::assertTrue($bound->answersEveryConjunct());
+    }
+
+    public function test_a_fraction_on_an_integer_column_binds_between_two_integers(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('id'));
+        $greater = parquet_column('id')->greaterThan(2.5);
+        $set = parquet_column('id')->in([1, 2.5]);
+        $bound = BoundFilter::bind($greater->and($set), $schema, new Options());
+
+        $greaterLeaf = $bound->leaf($greater);
+        $setLeaf = $bound->leaf($set);
+
+        static::assertInstanceOf(ResolvedLeaf::class, $greaterLeaf);
+        static::assertInstanceOf(ResolvedLeaf::class, $setLeaf);
+        static::assertEquals(
+            new PhysicalIntervals(PhysicalOrder::Signed, [new PhysicalInterval(2, false, null, false)]),
+            $greaterLeaf->intervals,
+        );
+        static::assertEquals(
+            new PhysicalIntervals(PhysicalOrder::Signed, [new PhysicalInterval(1, true, 1, true)]),
+            $setLeaf->intervals,
+        );
+    }
+
+    public function test_an_uppercase_uuid_binds_as_its_lowercase_form(): void
+    {
+        $schema = Schema::with(FlatColumn::uuid('u'));
+        $upper = parquet_column('u')->equals('ABCDEF00-0000-4000-8000-000000000000');
+        $lower = parquet_column('u')->equals('abcdef00-0000-4000-8000-000000000000');
+
+        $upperLeaf = BoundFilter::bind($upper, $schema, new Options())->leaf($upper);
+
+        static::assertEquals(BoundFilter::bind($lower, $schema, new Options())->leaf($lower), $upperLeaf);
+        static::assertInstanceOf(ResolvedLeaf::class, $upperLeaf);
+        static::assertNotNull($upperLeaf->intervals);
+    }
+
+    public function test_the_filter_is_kept_as_given(): void
+    {
+        $filter = parquet_column('id')->equals(1);
+
+        static::assertSame(
+            $filter,
+            BoundFilter::bind($filter, Schema::with(FlatColumn::int64('id')), new Options())->filter(),
+        );
+    }
+
+    public function test_a_leaf_of_another_tree_is_refused(): void
+    {
+        $bound = BoundFilter::bind(
+            parquet_column('id')->equals(1),
+            Schema::with(FlatColumn::int64('id')),
+            new Options(),
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('The leaf is not part of the bound filter');
+
+        $bound->leaf(parquet_column('id')->equals(1));
+    }
+
+    public function test_the_row_filter_of_a_fully_bound_filter_is_the_filter_itself(): void
+    {
+        $bound = BoundFilter::bind(
+            parquet_column('id')->equals(1)->and(parquet_column('missing')->isNull()),
+            Schema::with(FlatColumn::int64('id')),
+            new Options(),
+        );
+
+        static::assertSame($bound, $bound->rowFilter());
+        static::assertNull($bound->residual());
+        static::assertTrue($bound->answersEveryConjunct());
+    }
+
+    public function test_an_empty_all_is_fully_bound_without_a_row_filter(): void
+    {
+        $bound = BoundFilter::bind(new All(), Schema::with(FlatColumn::int64('id')), new Options());
+
+        static::assertTrue($bound->answersEveryConjunct());
+        static::assertNull($bound->rowFilter());
+        static::assertNull($bound->residual());
+    }
+
+    public function test_the_row_filter_keeps_the_root_conjuncts_whose_leaves_are_all_answered(): void
+    {
+        $id = parquet_column('id')->equals(1);
+        $name = parquet_column('name')->startsWith('a');
+        $refused = parquet_column('id')->equals('1');
+        $mixed = parquet_column('name')->isNull()->or(parquet_column('id')->equals('2'));
+        $bound = BoundFilter::bind(
+            new All($id->and($refused), $name->negate(), $mixed),
+            Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+            new Options(),
+        );
+
+        $rowFilter = $bound->rowFilter();
+
+        static::assertNotNull($rowFilter);
+        static::assertEquals($id->and($name->negate()), $rowFilter->filter());
+        static::assertSame($bound->leaf($id), $rowFilter->leaf($id));
+        static::assertSame($bound->leaf($name), $rowFilter->leaf($name));
+        static::assertSame(
+            ['id', 'name'],
+            array_map(static fn(FlatColumn $column): string => $column->flatPath(), $rowFilter->columns()),
+        );
+        static::assertEquals($refused->and($mixed), $bound->residual()?->filter());
+        static::assertFalse($bound->answersEveryConjunct());
+    }
+
+    public function test_a_single_answered_conjunct_is_the_row_filter_without_a_conjunction(): void
+    {
+        $id = parquet_column('id')->lessThan(5);
+        $refused = parquet_column('id')->equals('x');
+        $bound = BoundFilter::bind($id->and($refused), Schema::with(FlatColumn::int64('id')), new Options());
+
+        static::assertSame($id, $bound->rowFilter()?->filter());
+        static::assertSame(
+            ['id'],
+            array_map(
+                static fn(FlatColumn $column): string => $column->flatPath(),
+                $bound->rowFilter()?->columns() ?? [],
+            ),
+        );
+        static::assertSame($refused, $bound->residual()?->filter());
+    }
+
+    public function test_a_row_leaf_is_an_answered_or_absent_leaf_and_another_is_refused(): void
+    {
+        $id = parquet_column('id')->equals(1);
+        $missing = parquet_column('missing')->isNull();
+        $refused = parquet_column('id')->equals('1');
+        $bound = BoundFilter::bind(
+            new All($id, $missing, $refused),
+            Schema::with(FlatColumn::int64('id')),
+            new Options(),
+        );
+
+        static::assertSame($bound->leaf($id), $bound->rowLeaf($id));
+        static::assertSame($bound->leaf($missing), $bound->rowLeaf($missing));
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Rows are evaluated on leaves answered exactly, the leaf on "id" is not');
+
+        $bound->rowLeaf($refused);
+    }
+
+    public function test_the_row_filter_of_a_lone_answered_leaf_is_the_filter_itself(): void
+    {
+        $bound = BoundFilter::bind(
+            parquet_column('id')->equals(1),
+            Schema::with(FlatColumn::int64('id')),
+            new Options(),
+        );
+
+        static::assertSame($bound, $bound->rowFilter());
+    }
+
+    public function test_no_row_filter_when_no_root_conjunct_is_answered(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('id'));
+
+        static::assertNull(BoundFilter::bind(parquet_column('id')->equals('1'), $schema, new Options())->rowFilter());
+        static::assertNull(
+            BoundFilter::bind(
+                parquet_column('id')->equals(1)->or(parquet_column('id')->equals('1')),
+                $schema,
+                new Options(),
+            )->rowFilter(),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/EqualRangeTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/EqualRangeTest.php
new file mode 100644
index 0000000000..08a5bae04d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/EqualRangeTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding;
+
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\OutOfDomain;
+use PHPUnit\Framework\TestCase;
+
+final class EqualRangeTest extends TestCase
+{
+    public function test_a_point_is_its_own_low_and_high(): void
+    {
+        static::assertEquals(new EqualRange('a', 'a'), EqualRange::point('a'));
+        static::assertEquals(
+            new EqualRange(OutOfDomain::Above, OutOfDomain::Above),
+            EqualRange::point(OutOfDomain::Above),
+        );
+    }
+
+    public function test_an_integer_edge_beyond_the_domain_is_out_of_it(): void
+    {
+        static::assertEquals(new EqualRange(1, 2), EqualRange::integers('1', '2', 0, 10));
+        static::assertEquals(new EqualRange(OutOfDomain::Below, 10), EqualRange::integers('-1', '10', 0, 10));
+        static::assertEquals(new EqualRange(0, OutOfDomain::Above), EqualRange::integers('0', '11', 0, 10));
+    }
+
+    public function test_a_value_on_the_grid_is_one_physical_value_and_one_off_it_none(): void
+    {
+        static::assertEquals(new EqualRange(2, 2), EqualRange::grid('2000', '1000', -10, 10));
+        static::assertEquals(new EqualRange(2, 1), EqualRange::grid('1500', '1000', -10, 10));
+        static::assertEquals(new EqualRange(-1, -2), EqualRange::grid('-1500', '1000', -10, 10));
+        static::assertEquals(new EqualRange(OutOfDomain::Above, 10), EqualRange::grid('10500', '1000', -10, 10));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/LeafResolverTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/LeafResolverTest.php
new file mode 100644
index 0000000000..aa69e04d13
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/LeafResolverTest.php
@@ -0,0 +1,149 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding;
+
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\AbsentLeaf;
+use Flow\Parquet\Filter\Binding\LeafResolver;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\PhysicalInterval;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Binding\RefusedLeaf;
+use Flow\Parquet\Filter\Binding\ResolvedLeaf;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class LeafResolverTest extends TestCase
+{
+    public function test_a_struct_leaf_resolves_to_its_root_column_and_field_path(): void
+    {
+        $city = NestedColumn::struct('address', [NestedColumn::struct('place', [FlatColumn::string('city')])]);
+        $schema = Schema::with($city);
+
+        $resolution = LeafResolver::resolve(
+            parquet_column('address.place.city')->equals('x'),
+            $schema,
+            DataConverter::initialize(new Options()),
+        );
+
+        static::assertInstanceOf(ResolvedLeaf::class, $resolution);
+        static::assertSame($schema->get('address.place.city'), $resolution->column);
+        static::assertSame(LiteralDomain::Bytes, $resolution->domain);
+        static::assertSame('address', $resolution->root);
+        static::assertSame(['place', 'city'], $resolution->fields);
+        static::assertSame(['x'], $resolution->literals);
+        static::assertEquals(
+            new PhysicalIntervals(PhysicalOrder::Bytes, [new PhysicalInterval('x', true, 'x', true)]),
+            $resolution->intervals,
+        );
+    }
+
+    public function test_literals_are_normalised_and_a_column_the_file_lacks_is_absent(): void
+    {
+        $schema = Schema::with(FlatColumn::uuid('u'));
+        $converters = DataConverter::initialize(new Options());
+        $resolution = LeafResolver::resolve(
+            parquet_column('u')->in(['ABCDEF00-0000-4000-8000-000000000000']),
+            $schema,
+            $converters,
+        );
+
+        static::assertInstanceOf(ResolvedLeaf::class, $resolution);
+        static::assertSame(['abcdef00-0000-4000-8000-000000000000'], $resolution->literals);
+        static::assertEquals(
+            new AbsentLeaf(),
+            LeafResolver::resolve(parquet_column('missing')->isNull(), $schema, $converters),
+        );
+    }
+
+    public function test_is_null_holds_for_no_physical_value_even_on_an_unordered_column(): void
+    {
+        $isNull = LeafResolver::resolve(
+            parquet_column('t')->isNull(),
+            Schema::with(FlatColumnMother::int96()),
+            DataConverter::initialize(new Options()),
+        );
+
+        static::assertInstanceOf(ResolvedLeaf::class, $isNull);
+        static::assertEquals(new PhysicalIntervals(PhysicalOrder::Unordered, []), $isNull->intervals);
+    }
+
+    public function test_a_leaf_without_an_exact_pre_image_resolves_without_intervals(): void
+    {
+        $json = LeafResolver::resolve(
+            parquet_column('doc')->equals('{}'),
+            Schema::with(FlatColumn::json('doc')),
+            DataConverter::initialize(new Options()),
+        );
+
+        static::assertInstanceOf(ResolvedLeaf::class, $json);
+        static::assertNull($json->intervals);
+    }
+
+    #[TestWith(['big', ' 9', 'Column "big" (INT64 (INTEGER)) cannot hold the string literal \' 9\''])]
+    #[TestWith(['amount', 'x', 'Column "amount" (INT64 (DECIMAL)) cannot hold the string literal \'x\''])]
+    #[TestWith(['ts', 'x', 'Column "ts" (INT64 (TIMESTAMP)) cannot hold the string literal \'x\''])]
+    #[TestWith(['flag', 1, 'Column "flag" (BOOLEAN) cannot hold the int literal 1'])]
+    public function test_a_literal_the_column_cannot_hold_is_refused_with_the_column_type(
+        string $column,
+        int|string $literal,
+        string $reason,
+    ): void {
+        static::assertEquals(
+            new RefusedLeaf($reason),
+            LeafResolver::resolve(
+                parquet_column($column)->equals($literal),
+                Schema::with(
+                    FlatColumnMother::uint64('big'),
+                    FlatColumn::decimal('amount', 10, 2),
+                    FlatColumn::dateTime('ts'),
+                    FlatColumn::boolean('flag'),
+                ),
+                DataConverter::initialize(new Options()),
+            ),
+        );
+    }
+
+    public function test_a_struct_column_and_a_leaf_inside_a_list_are_refused(): void
+    {
+        $schema = Schema::with(
+            NestedColumn::struct('address', [FlatColumn::string('city')]),
+            NestedColumn::list('tags', ListElement::string()),
+        );
+        $converters = DataConverter::initialize(new Options());
+
+        static::assertEquals(
+            new RefusedLeaf('Filter column "address" is not a leaf column'),
+            LeafResolver::resolve(parquet_column('address')->isNull(), $schema, $converters),
+        );
+        static::assertEquals(
+            new RefusedLeaf(
+                'Filter column "tags.list.element" lies inside a list or a map, where a row holds no single value',
+            ),
+            LeafResolver::resolve(parquet_column('tags.list.element')->equals('a'), $schema, $converters),
+        );
+    }
+
+    public function test_a_prefix_on_a_column_without_strings_is_refused(): void
+    {
+        static::assertEquals(
+            new RefusedLeaf('Column "i" (INT64) holds no strings for a prefix'),
+            LeafResolver::resolve(
+                parquet_column('i')->startsWith('1'),
+                Schema::with(FlatColumn::int64('i')),
+                DataConverter::initialize(new Options()),
+            ),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/LiteralDomainTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/LiteralDomainTest.php
new file mode 100644
index 0000000000..89a01645a5
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/LiteralDomainTest.php
@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Binding\LiteralDomain;
+use Flow\Parquet\Filter\Binding\PreImage\BooleanPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\BytesPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\DatePreImage;
+use Flow\Parquet\Filter\Binding\PreImage\DecimalPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\DoublePreImage;
+use Flow\Parquet\Filter\Binding\PreImage\Float32PreImage;
+use Flow\Parquet\Filter\Binding\PreImage\IntegerPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\TimestampPreImage;
+use Flow\Parquet\Filter\Binding\PreImage\UnsignedInt64PreImage;
+use Flow\Parquet\Filter\Binding\PreImage\UuidPreImage;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use PHPUnit\Framework\TestCase;
+
+use const NAN;
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+final class LiteralDomainTest extends TestCase
+{
+    public function test_each_column_kind_maps_to_the_domain_and_pre_image_of_its_decoded_values(): void
+    {
+        $of = static fn(FlatColumn $column): array => LiteralDomain::forColumn(
+            $column,
+            DataConverter::initialize(new Options())->resolveConverter($column),
+        );
+
+        static::assertEquals([LiteralDomain::Boolean, new BooleanPreImage()], $of(FlatColumn::boolean('b')));
+        static::assertEquals(
+            [LiteralDomain::Number, new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX)],
+            $of(FlatColumn::int64('i')),
+        );
+        static::assertEquals(
+            [LiteralDomain::Number, new IntegerPreImage(-2_147_483_648, 2_147_483_647)],
+            $of(FlatColumn::int32('i')),
+        );
+        static::assertEquals([LiteralDomain::Number, new IntegerPreImage(0, 255)], $of(FlatColumnMother::uint8()));
+        static::assertEquals(
+            [LiteralDomain::Number, new IntegerPreImage(0, 4_294_967_295)],
+            $of(FlatColumnMother::uint32()),
+        );
+        static::assertEquals([LiteralDomain::Number, new DoublePreImage()], $of(FlatColumn::double('d')));
+        static::assertEquals([LiteralDomain::Number, new Float32PreImage()], $of(FlatColumn::float('f')));
+        static::assertEquals(
+            [LiteralDomain::Number, DecimalPreImage::forColumn(FlatColumn::decimal('m', 10, 2))],
+            $of(FlatColumn::decimal('m', 10, 2)),
+        );
+        static::assertSame(LiteralDomain::UnsignedInteger64, $of(FlatColumnMother::uint64())[0]);
+        static::assertInstanceOf(UnsignedInt64PreImage::class, $of(FlatColumnMother::uint64())[1]);
+        static::assertEquals([LiteralDomain::Bytes, new BytesPreImage()], $of(FlatColumn::string('s')));
+        static::assertEquals([LiteralDomain::Bytes, new BytesPreImage()], $of(FlatColumn::enum('e')));
+        static::assertEquals([LiteralDomain::Bytes, null], $of(FlatColumn::json('j')));
+        static::assertSame(LiteralDomain::Uuid, $of(FlatColumn::uuid('u'))[0]);
+        static::assertInstanceOf(UuidPreImage::class, $of(FlatColumn::uuid('u'))[1]);
+        static::assertEquals([LiteralDomain::DateTime, new DatePreImage()], $of(FlatColumn::date('day')));
+        static::assertEquals(
+            [LiteralDomain::DateTime, new TimestampPreImage(TimeUnit::MICROSECONDS)],
+            $of(FlatColumn::dateTime('ts')),
+        );
+        static::assertEquals([LiteralDomain::None, null], $of(FlatColumn::time('t')));
+        static::assertEquals([LiteralDomain::None, null], $of(FlatColumnMother::float16()));
+        static::assertEquals([LiteralDomain::None, null], $of(FlatColumnMother::interval()));
+        static::assertEquals([LiteralDomain::Number, null], $of(FlatColumnMother::byteArrayDecimal()));
+        static::assertEquals([LiteralDomain::None, null], LiteralDomain::forColumn(FlatColumnMother::int96(), null));
+    }
+
+    public function test_a_domain_holds_only_the_literals_its_values_compare_with(): void
+    {
+        static::assertTrue(LiteralDomain::Boolean->holds(true));
+        static::assertFalse(LiteralDomain::Boolean->holds(1));
+        static::assertTrue(LiteralDomain::Number->holds(2.5));
+        static::assertFalse(LiteralDomain::Number->holds('1'));
+        static::assertTrue(LiteralDomain::UnsignedInteger64->holds('18446744073709551616'));
+        static::assertTrue(LiteralDomain::UnsignedInteger64->holds('0'));
+        static::assertTrue(LiteralDomain::UnsignedInteger64->holds(-1));
+        static::assertTrue(LiteralDomain::UnsignedInteger64->holds(1.5));
+        static::assertFalse(LiteralDomain::UnsignedInteger64->holds(' 9'));
+        static::assertFalse(LiteralDomain::UnsignedInteger64->holds('1e1'));
+        static::assertFalse(LiteralDomain::UnsignedInteger64->holds('09'));
+        static::assertTrue(LiteralDomain::Uuid->holds('00000000-0000-4000-8000-00000000000a'));
+        static::assertFalse(LiteralDomain::Uuid->holds('00000000-0000-4000-8000-00000000000A'));
+        static::assertTrue(LiteralDomain::DateTime->holds(new DateTimeImmutable()));
+        static::assertFalse(LiteralDomain::DateTime->holds('2024-01-01'));
+        static::assertFalse(LiteralDomain::None->holds('x'));
+        static::assertTrue(LiteralDomain::Uuid->holdsPrefix());
+        static::assertSame(
+            '00000000-0000-4000-8000-0000000000aa',
+            LiteralDomain::Uuid->normalise('00000000-0000-4000-8000-0000000000AA'),
+        );
+        static::assertSame('ABC', LiteralDomain::Bytes->normalise('ABC'));
+        static::assertFalse(LiteralDomain::Number->holdsPrefix());
+    }
+
+    public function test_values_equal_by_the_domain_share_a_key(): void
+    {
+        static::assertSame(LiteralDomain::Number->key(1), LiteralDomain::Number->key(1.0));
+        static::assertSame(LiteralDomain::Number->key(0), LiteralDomain::Number->key(-0.0));
+        static::assertSame(2 ** 53, LiteralDomain::Number->key((float) 2 ** 53));
+        static::assertNotSame(LiteralDomain::Number->key(1), LiteralDomain::Number->key(1.5));
+        static::assertNull(LiteralDomain::Number->key(NAN));
+        static::assertSame(
+            LiteralDomain::DateTime->key(new DateTimeImmutable('2024-01-01 02:00 +02:00')),
+            LiteralDomain::DateTime->key(new DateTimeImmutable('2024-01-01 00:00 UTC')),
+        );
+        static::assertSame(LiteralDomain::UnsignedInteger64->key(10), LiteralDomain::UnsignedInteger64->key('10'));
+        static::assertSame('a', LiteralDomain::Bytes->key('a'));
+    }
+
+    public function test_a_value_ordered_rather_than_hashed_has_no_key(): void
+    {
+        static::assertNull(LiteralDomain::UnsignedInteger64->key(1.0));
+        static::assertNull(LiteralDomain::Boolean->key(true));
+        static::assertNull(LiteralDomain::None->key('a'));
+        static::assertNull(LiteralDomain::Bytes->key(1));
+        static::assertNull(LiteralDomain::DateTime->key('2024-01-01'));
+        static::assertNull(LiteralDomain::Number->key('1'));
+        static::assertNull(LiteralDomain::Number->key(2 ** 53 + 1));
+        static::assertNull(LiteralDomain::Number->key(-2 ** 53 - 1));
+        static::assertNull(LiteralDomain::Number->key((float) 2 ** 60));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PhysicalIntervalsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PhysicalIntervalsTest.php
new file mode 100644
index 0000000000..3a3b192b0e
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PhysicalIntervalsTest.php
@@ -0,0 +1,336 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding;
+
+use DateTimeImmutable;
+use Flow\Parquet\Data\PhysicalOrder;
+use Flow\Parquet\Filter\Binding\PhysicalInterval;
+use Flow\Parquet\Filter\Binding\PhysicalIntervals;
+use Flow\Parquet\Filter\Binding\PreImage\IntegerPreImage;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Context\PreImageDifferential;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\Binary\encode_decimal;
+
+use const INF;
+use const NAN;
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+final class PhysicalIntervalsTest extends TestCase
+{
+    public function test_a_set_is_the_union_of_its_equalities_sorted_each_once(): void
+    {
+        static::assertSame(
+            [[1, true, 1, true], [3, true, 3, true]],
+            PhysicalIntervalEdges::of(PhysicalIntervals::preImageOfSet(
+                new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX),
+                PhysicalOrder::Signed,
+                [3, 1, 3],
+            )),
+        );
+        static::assertSame(
+            [],
+            PhysicalIntervalEdges::of(PhysicalIntervals::preImageOfSet(
+                new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX),
+                PhysicalOrder::Signed,
+                [],
+            )),
+        );
+        static::assertNull(PhysicalIntervals::preImageOfSet(
+            new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX),
+            PhysicalOrder::Signed,
+            [1, 'a'],
+        ));
+        static::assertTrue(
+            PhysicalIntervals::preImageOfSet(
+                new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX),
+                PhysicalOrder::Signed,
+                [],
+            )?->isEmpty(),
+        );
+    }
+
+    #[TestWith([0, true])]
+    #[TestWith([1, false])]
+    #[TestWith([2, false])]
+    #[TestWith([3, true])]
+    #[TestWith([5, false])]
+    #[TestWith([6, true])]
+    #[TestWith([8, true])]
+    #[TestWith([9, false])]
+    #[TestWith([10, true])]
+    #[TestWith([99, true])]
+    public function test_contains_finds_the_value_among_sorted_intervals(int $value, bool $contained): void
+    {
+        $intervals = new PhysicalIntervals(PhysicalOrder::Signed, [
+            new PhysicalInterval(null, false, 1, false),
+            new PhysicalInterval(3, true, 3, true),
+            new PhysicalInterval(5, false, 8, true),
+            new PhysicalInterval(10, true, null, false),
+        ]);
+
+        static::assertSame($contained, $intervals->contains($value));
+    }
+
+    public function test_contains_compares_floats_as_ieee_754(): void
+    {
+        static::assertFalse((new PhysicalIntervals(PhysicalOrder::Double, [PhysicalInterval::unbounded()]))->contains(
+            NAN,
+        ));
+        static::assertTrue((new PhysicalIntervals(PhysicalOrder::Double, [new PhysicalInterval(
+            0.0,
+            true,
+            0.0,
+            true,
+        )]))->contains(-0.0));
+        static::assertFalse((new PhysicalIntervals(PhysicalOrder::Double, [new PhysicalInterval(
+            -0.0,
+            false,
+            null,
+            false,
+        )]))->contains(0.0));
+        static::assertTrue((new PhysicalIntervals(PhysicalOrder::Double, [new PhysicalInterval(
+            -0.0,
+            true,
+            1.0,
+            false,
+        )]))->contains(0.0));
+    }
+
+    public function test_covers_and_disjoint_honour_each_bound_and_its_inclusion(): void
+    {
+        $intervals = new PhysicalIntervals(PhysicalOrder::Signed, [
+            new PhysicalInterval(1, true, 5, false),
+            new PhysicalInterval(8, false, null, false),
+        ]);
+
+        static::assertTrue($intervals->covers(1, 4));
+        static::assertFalse($intervals->covers(1, 5));
+        static::assertFalse($intervals->covers(0, 4));
+        static::assertFalse($intervals->covers(8, 9));
+        static::assertTrue($intervals->covers(9, PHP_INT_MAX));
+        static::assertTrue($intervals->disjoint(5, 8));
+        static::assertTrue($intervals->disjoint(-3, 0));
+        static::assertFalse($intervals->disjoint(4, 6));
+        static::assertFalse($intervals->disjoint(7, 9));
+        static::assertTrue((new PhysicalIntervals(PhysicalOrder::Signed, []))->disjoint(1, 1));
+        static::assertFalse((new PhysicalIntervals(PhysicalOrder::Signed, []))->covers(1, 1));
+        static::assertTrue((new PhysicalIntervals(PhysicalOrder::Signed, [PhysicalInterval::unbounded()]))->covers(
+            1,
+            1,
+        ));
+    }
+
+    public function test_covers_and_disjoint_search_among_many_intervals_and_ones_meeting_at_an_exclusive_bound(): void
+    {
+        $intervals = new PhysicalIntervals(PhysicalOrder::Signed, [
+            new PhysicalInterval(0, true, 2, true),
+            new PhysicalInterval(10, true, 12, true),
+            new PhysicalInterval(20, true, 25, true),
+            new PhysicalInterval(25, false, 30, true),
+            new PhysicalInterval(40, true, 42, true),
+        ]);
+
+        static::assertTrue($intervals->covers(11, 12));
+        static::assertTrue($intervals->covers(25, 25));
+        static::assertTrue($intervals->covers(26, 30));
+        static::assertFalse($intervals->covers(24, 26));
+        static::assertFalse($intervals->covers(12, 13));
+        static::assertTrue($intervals->contains(25));
+        static::assertTrue($intervals->disjoint(31, 39));
+        static::assertTrue($intervals->disjoint(-5, -1));
+        static::assertTrue($intervals->disjoint(43, 50));
+        static::assertFalse($intervals->disjoint(30, 35));
+        static::assertFalse($intervals->disjoint(35, 40));
+        static::assertFalse($intervals->disjoint(-5, 0));
+        static::assertFalse($intervals->disjoint(25, 25));
+    }
+
+    public function test_covers_and_disjoint_compare_in_the_column_order(): void
+    {
+        $intervals = new PhysicalIntervals(PhysicalOrder::Unsigned64, [new PhysicalInterval(null, false, -1, true)]);
+
+        static::assertTrue($intervals->covers(0, PHP_INT_MAX));
+        static::assertFalse($intervals->disjoint(PHP_INT_MIN, -2));
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, list<bool|float|int|string>, list<bool|DateTimeImmutable|float|int|string>}>
+     */
+    public static function columns_physical_values_and_literals(): Generator
+    {
+        yield 'double' => [
+            FlatColumn::double('x'),
+            [-INF, -1.0, -0.0, 0.0, 1.0, 2.0 ** 53, INF],
+            [INF, -INF, 0.0, -0.0, 1, 1.0, 1.0E39, -1.0E39],
+        ];
+        yield 'float' => [
+            FlatColumn::float('x'),
+            [-INF, -3.3999999521443642E+38, -1.0, -0.0, 0.0, 0.10000000149011612, 1.0, 3.3999999521443642E+38, INF],
+            [1.0E39, -1.0E39, 0.1, INF, -INF, 1.0E-50, -1.0E-50, 16_777_217],
+        ];
+        yield 'int64' => [
+            FlatColumn::int64('x'),
+            [PHP_INT_MIN, -3, -2, 0, 2, 3, PHP_INT_MAX],
+            [2.5, -2.5, 2.0, 3, -3, 9_007_199_254_740_992.0],
+        ];
+        yield 'int32' => [
+            FlatColumn::int32('x'),
+            [-2_147_483_648, -1, 0, 2, 3, 2_147_483_647],
+            [2.5, -0.5, 2_147_483_648, -2_147_483_649, 0],
+        ];
+        yield 'int8' => [
+            new FlatColumn('x', PhysicalType::INT32, logicalType: LogicalType::integer(8, true)),
+            [-128, -1, 0, 127],
+            [-129, -128, 127, 128, 0, 0.5],
+        ];
+        yield 'uint8' => [FlatColumnMother::uint8(), [0, 1, 127, 128, 255], [0, 128, 255, 256, -1, 127.5]];
+        yield 'uint32' => [
+            FlatColumnMother::uint32(),
+            [0, 1, 2_147_483_647, -2_147_483_648, -1],
+            [0, 1, 2_147_483_648, 4_294_967_295, 4_294_967_296, -1, 2_147_483_647.5],
+        ];
+        yield 'uint64' => [
+            FlatColumnMother::uint64(),
+            [0, 1, 9, 10, PHP_INT_MAX, PHP_INT_MIN, -1],
+            [0, 1, 9, '10', '9223372036854775808', '18446744073709551615', '18446744073709551616', -1, PHP_INT_MAX],
+        ];
+        yield 'int64 decimal' => [
+            FlatColumnMother::int64Decimal(),
+            [-1_000, -105, -11, -10, 0, 10, 11, 105, 1_000],
+            [0.1, 0.105, -0.105, 1.0, -2.5, 3.333, 1.0E20, -1.0E20, 0, 1.0E-9, -0.0],
+        ];
+        yield 'byte array decimal' => [
+            new FlatColumn('x', PhysicalType::BYTE_ARRAY, ConvertedType::DECIMAL, LogicalType::decimal(2, 12)),
+            [
+                encode_decimal(-10.0, 12, 2, null),
+                encode_decimal(-0.11, 12, 2, null),
+                encode_decimal(0.0, 12, 2, null),
+                encode_decimal(0.1, 12, 2, null),
+                encode_decimal(0.11, 12, 2, null),
+                encode_decimal(10.0, 12, 2, null),
+            ],
+            [0.1, 0.105, -0.105, -2.5, 3.333, 1.0E20, -1.0E20, 0],
+        ];
+        yield 'date' => [
+            FlatColumn::date('x'),
+            [-3, -1, 0, 1, 3],
+            [
+                new DateTimeImmutable('1970-01-01 00:00 UTC'),
+                new DateTimeImmutable('1970-01-02 00:00 +02:00'),
+                new DateTimeImmutable('1969-12-31 12:00 UTC'),
+                new DateTimeImmutable('1970-01-01 00:00:00.000001 UTC'),
+            ],
+        ];
+
+        foreach (['MILLIS' => 1, 'MICROS' => 1_000, 'NANOS' => 1_000_000] as $unit => $perMilli) {
+            yield 'timestamp ' . $unit => [
+                FlatColumnMother::timestamp(TimeUnit::from($unit)),
+                [-$perMilli - 1, -$perMilli, -1, 0, 1, $perMilli, $perMilli + 1],
+                [
+                    new DateTimeImmutable('@0'),
+                    new DateTimeImmutable('1970-01-01 00:00:00.0015 UTC'),
+                    new DateTimeImmutable('1969-12-31 23:59:59.999 UTC'),
+                    new DateTimeImmutable('1970-01-01 00:00:00.001 UTC'),
+                ],
+            ];
+        }
+
+        yield 'boolean' => [FlatColumn::boolean('x'), [false, true], [false, true]];
+        yield 'string' => [
+            FlatColumn::string('x'),
+            ['', 'a', "a\x00", 'ab', "\xC3\xA9", "\xFF"],
+            ['a', '', "\xC3\xA9", 'b'],
+        ];
+    }
+
+    /**
+     * @param list<bool|float|int|string> $physicals
+     * @param list<bool|DateTimeImmutable|float|int|string> $literals
+     */
+    #[DataProvider('columns_physical_values_and_literals')]
+    public function test_a_physical_value_is_in_the_pre_image_exactly_when_its_decoded_value_matches(
+        FlatColumn $column,
+        array $physicals,
+        array $literals,
+    ): void {
+        static::assertSame([], PreImageDifferential::mismatches($column, $physicals, $literals));
+    }
+
+    /**
+     * @param list<array{0: ?float, 1: bool, 2: ?float, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', INF, [[INF, true, INF, true]]])]
+    #[TestWith(['GreaterThanOrEqual', INF, [[INF, true, null, false]]])]
+    #[TestWith(['LessThan', INF, [[null, false, INF, false]]])]
+    #[TestWith(['GreaterThan', INF, [[INF, false, null, false]]])]
+    #[TestWith(['Equal', -INF, [[-INF, true, -INF, true]]])]
+    #[TestWith(['GreaterThan', -INF, [[-INF, false, null, false]]])]
+    #[TestWith(['LessThanOrEqual', -INF, [[null, false, -INF, true]]])]
+    public function test_an_infinity_is_a_value_of_a_double_column(
+        string $operator,
+        float $literal,
+        array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::double('x'),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', 11, []])]
+    #[TestWith(['GreaterThanOrEqual', 11, []])]
+    #[TestWith(['LessThan', 11, [[null, false, null, false]]])]
+    #[TestWith(['LessThan', -1, []])]
+    #[TestWith(['GreaterThan', -1, [[null, false, null, false]]])]
+    #[TestWith(['LessThanOrEqual', 10, [[null, false, 10, true]]])]
+    public function test_an_edge_beyond_the_domain_empties_or_unbounds_the_interval(
+        string $operator,
+        int $literal,
+        array $expected,
+    ): void {
+        static::assertSame(
+            $expected,
+            PhysicalIntervalEdges::of(PhysicalIntervals::preImage(
+                new IntegerPreImage(0, 10),
+                PhysicalOrder::Signed,
+                OperatorMother::named($operator),
+                $literal,
+            )),
+        );
+    }
+
+    public function test_a_literal_the_pre_image_cannot_compare_has_no_intervals(): void
+    {
+        static::assertNull(PhysicalIntervals::preImage(
+            new IntegerPreImage(0, 10),
+            PhysicalOrder::Signed,
+            Operator::Equal,
+            'a',
+        ));
+        static::assertNull(PhysicalIntervals::preImageOfSet(
+            new IntegerPreImage(0, 10),
+            PhysicalOrder::Signed,
+            [1, 'a'],
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/BooleanPreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/BooleanPreImageTest.php
new file mode 100644
index 0000000000..df533bafc0
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/BooleanPreImageTest.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use PHPUnit\Framework\TestCase;
+
+final class BooleanPreImageTest extends TestCase
+{
+    public function test_a_boolean_binds_its_physical_value(): void
+    {
+        static::assertSame(
+            [[null, false, true, false]],
+            PhysicalIntervalEdges::ofComparison(FlatColumn::boolean('b'), Operator::LessThan, true),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/BytesPreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/BytesPreImageTest.php
new file mode 100644
index 0000000000..da2fe659c9
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/BytesPreImageTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Filter\Binding\PreImage\BytesPreImage;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class BytesPreImageTest extends TestCase
+{
+    public function test_a_string_binds_its_bytes_and_json_has_no_pre_image(): void
+    {
+        static::assertSame(
+            [[null, false, 'b', false]],
+            PhysicalIntervalEdges::ofComparison(FlatColumn::string('s'), Operator::LessThan, 'b'),
+        );
+        static::assertNull(PhysicalIntervalEdges::intervals(FlatColumn::json('j'), Operator::Equal, '{}'));
+    }
+
+    /**
+     * @param list<array{0: ?string, 1: bool, 2: ?string, 3: bool}> $expected
+     */
+    #[TestWith(['ab', [['ab', true, 'ac', false]]])]
+    #[TestWith(["a\xFF", [["a\xFF", true, 'b', false]]])]
+    #[TestWith(["\xFF\xFF", [["\xFF\xFF", true, null, false]]])]
+    #[TestWith(['', [[null, false, null, false]]])]
+    public function test_a_prefix_is_the_range_up_to_its_increment(string $prefix, array $expected): void
+    {
+        static::assertSame($expected, PhysicalIntervalEdges::of((new BytesPreImage())->startsWith($prefix)));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DatePreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DatePreImageTest.php
new file mode 100644
index 0000000000..c668385116
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DatePreImageTest.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class DatePreImageTest extends TestCase
+{
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', '2024-01-01T00:00:00Z', [[19723, true, 19723, true]]])]
+    #[TestWith(['Equal', '2024-01-01T12:00:00Z', []])]
+    #[TestWith(['Equal', '2024-01-01T00:00:00+02:00', []])]
+    #[TestWith(['GreaterThan', '2023-12-31T19:00:00Z', [[19722, false, null, false]]])]
+    #[TestWith(['GreaterThanOrEqual', '2024-01-01T12:00:00Z', [[19724, true, null, false]]])]
+    #[TestWith(['LessThan', '2024-01-01T12:00:00Z', [[null, false, 19724, false]]])]
+    #[TestWith(['LessThanOrEqual', '2024-01-01T00:00:00Z', [[null, false, 19723, true]]])]
+    public function test_a_date_maps_the_literal_utc_instant_to_days(
+        string $operator,
+        string $literal,
+        array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::date('d'),
+            OperatorMother::named($operator),
+            new DateTimeImmutable($literal),
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DecimalPreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DecimalPreImageTest.php
new file mode 100644
index 0000000000..675a34c69b
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DecimalPreImageTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+
+final class DecimalPreImageTest extends TestCase
+{
+    /**
+     * @param null|list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', 12.34, [[1_234, true, 1_234, true]]])]
+    #[TestWith(['Equal', 12, [[1_200, true, 1_200, true]]])]
+    #[TestWith(['Equal', 12.345, []])]
+    #[TestWith(['LessThan', 12.345, [[null, false, 1_235, false]]])]
+    #[TestWith(['GreaterThan', 12.345, [[1_234, false, null, false]]])]
+    #[TestWith(['GreaterThan', -12.345, [[-1_235, false, null, false]]])]
+    #[TestWith(['Equal', 1.0E20, []])]
+    #[TestWith(['LessThan', 1.0E20, [[null, false, null, false]]])]
+    #[TestWith(['Equal', 'a', null])]
+    public function test_a_decimal_of_precision_10_round_trips_the_literal(
+        string $operator,
+        float|int|string $literal,
+        ?array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::decimal('d', 10, 2),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+
+    public function test_a_decimal_above_precision_15_is_unbound(): void
+    {
+        static::assertNull(PhysicalIntervalEdges::intervals(FlatColumn::decimal('d', 18, 2), Operator::Equal, 1.5));
+    }
+
+    public function test_a_fixed_length_decimal_has_byte_edges(): void
+    {
+        static::assertSame(
+            [[pack('J', 1_234), true, pack('J', 1_234), true]],
+            PhysicalIntervalEdges::ofComparison(FlatColumnMother::flbaDecimal(), Operator::Equal, 12.34),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DoublePreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DoublePreImageTest.php
new file mode 100644
index 0000000000..8be6c3a231
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/DoublePreImageTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use PHPUnit\Framework\TestCase;
+
+use const PHP_INT_MAX;
+
+final class DoublePreImageTest extends TestCase
+{
+    public function test_negative_zero_is_normalised_and_equal_to_positive_zero(): void
+    {
+        $intervals = PhysicalIntervalEdges::intervals(FlatColumn::double('x'), Operator::Equal, -0.0);
+
+        static::assertSame([[0.0, true, 0.0, true]], PhysicalIntervalEdges::of($intervals));
+        static::assertTrue($intervals?->covers(-0.0, -0.0));
+        static::assertFalse($intervals?->disjoint(-0.0, 0.0));
+    }
+
+    public function test_an_int_on_a_double_column_is_exact_up_to_2_pow_53(): void
+    {
+        static::assertSame(
+            [[3.0, true, 3.0, true]],
+            PhysicalIntervalEdges::ofComparison(FlatColumn::double('x'), Operator::Equal, 3),
+        );
+        static::assertNull(PhysicalIntervalEdges::intervals(FlatColumn::double('x'), Operator::Equal, PHP_INT_MAX));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/Float32PreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/Float32PreImageTest.php
new file mode 100644
index 0000000000..49f11ce7a8
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/Float32PreImageTest.php
@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use const INF;
+
+final class Float32PreImageTest extends TestCase
+{
+    /**
+     * @param null|list<array{0: ?float, 1: bool, 2: ?float, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', 0.5, [[0.5, true, 0.5, true]]])]
+    #[TestWith(['Equal', 1, [[1.0, true, 1.0, true]]])]
+    #[TestWith(['Equal', 0.1, []])]
+    #[TestWith(['LessThan', 0.1, [[null, false, 0.10000000149011612, false]]])]
+    #[TestWith(['GreaterThan', 0.1, [[0.09999999403953552, false, null, false]]])]
+    #[TestWith(['GreaterThan', -0.1, [[-0.10000000149011612, false, null, false]]])]
+    #[TestWith(['Equal', 'a', null])]
+    public function test_a_float_column_compares_with_the_double_of_each_float32(
+        string $operator,
+        float|int|string $literal,
+        ?array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::float('x'),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+
+    /**
+     * @param list<array{0: ?float, 1: bool, 2: ?float, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', 1.0E39, []])]
+    #[TestWith(['GreaterThanOrEqual', 1.0E39, [[INF, true, null, false]]])]
+    #[TestWith(['GreaterThan', 1.0E39, [[3.4028234663852886E+38, false, null, false]]])]
+    #[TestWith(['LessThan', 1.0E39, [[null, false, INF, false]]])]
+    #[TestWith(['LessThanOrEqual', -1.0E39, [[null, false, -INF, true]]])]
+    #[TestWith(['GreaterThan', -1.0E39, [[-INF, false, null, false]]])]
+    #[TestWith(['Equal', INF, [[INF, true, INF, true]]])]
+    public function test_a_literal_beyond_the_largest_float32_lies_next_to_the_infinity(
+        string $operator,
+        float $literal,
+        array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::float('x'),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/IntegerPreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/IntegerPreImageTest.php
new file mode 100644
index 0000000000..0923639218
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/IntegerPreImageTest.php
@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Filter\Binding\EqualRange;
+use Flow\Parquet\Filter\Binding\PreImage\IntegerPreImage;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use const INF;
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+final class IntegerPreImageTest extends TestCase
+{
+    /**
+     * @param null|list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith([9_007_199_254_740_992.0, [[9_007_199_254_740_992, true, 9_007_199_254_740_992, true]]])]
+    #[TestWith([9_007_199_254_740_994.0, null])]
+    #[TestWith([2.5, []])]
+    #[TestWith(['1', null])]
+    #[TestWith([true, null])]
+    public function test_a_float_on_int64_compares_exactly_up_to_2_pow_53(
+        bool|float|string $literal,
+        ?array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::int64('id'),
+            Operator::Equal,
+            $literal,
+        ));
+    }
+
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', 1_099_511_627_776, []])]
+    #[TestWith(['GreaterThan', 1_099_511_627_776, []])]
+    #[TestWith(['LessThan', 1_099_511_627_776, [[null, false, null, false]]])]
+    #[TestWith(['GreaterThan', -1_099_511_627_776, [[null, false, null, false]]])]
+    #[TestWith(['LessThanOrEqual', 2_147_483_647, [[null, false, 2_147_483_647, true]]])]
+    public function test_an_int32_literal_out_of_range_is_an_empty_or_full_interval(
+        string $operator,
+        int $literal,
+        array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::int32('id'),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith([4_294_967_295, [[4_294_967_295, true, 4_294_967_295, true]]])]
+    #[TestWith([4_294_967_296, []])]
+    #[TestWith([-1, []])]
+    public function test_an_unsigned_int32_literal_is_bound_to_its_decoded_range(int $literal, array $expected): void
+    {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumnMother::uint32(),
+            Operator::Equal,
+            $literal,
+        ));
+    }
+
+    public function test_an_unsigned_int8_literal_is_bound_to_its_bit_width(): void
+    {
+        static::assertSame([], PhysicalIntervalEdges::ofComparison(FlatColumnMother::uint8(), Operator::Equal, 256));
+        static::assertSame(
+            [[255, true, 255, true]],
+            PhysicalIntervalEdges::ofComparison(FlatColumnMother::uint8(), Operator::Equal, 255),
+        );
+    }
+
+    public function test_a_string_literal_on_int64_is_unbound(): void
+    {
+        static::assertNull(PhysicalIntervalEdges::intervals(FlatColumn::int64('id'), Operator::Equal, '1'));
+    }
+
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', 2.5, []])]
+    #[TestWith(['GreaterThan', 2.5, [[2, false, null, false]]])]
+    #[TestWith(['GreaterThanOrEqual', 2.5, [[3, true, null, false]]])]
+    #[TestWith(['LessThan', 2.5, [[null, false, 3, false]]])]
+    #[TestWith(['LessThanOrEqual', -2.5, [[null, false, -3, true]]])]
+    public function test_a_fraction_lies_between_two_integers(string $operator, float $literal, array $expected): void
+    {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumn::int64('id'),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+
+    public function test_an_infinity_is_beyond_exact_integers(): void
+    {
+        static::assertNull((new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX))->equal(INF));
+        static::assertEquals(new EqualRange(3, 2), (new IntegerPreImage(PHP_INT_MIN, PHP_INT_MAX))->equal(2.5));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/TimestampPreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/TimestampPreImageTest.php
new file mode 100644
index 0000000000..de5d6be55f
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/TimestampPreImageTest.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class TimestampPreImageTest extends TestCase
+{
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', '1970-01-01T00:00:00.000001Z', [[1_000, true, 1_999, true]]])]
+    #[TestWith(['LessThanOrEqual', '1970-01-01T00:00:00.000001Z', [[null, false, 1_999, true]]])]
+    #[TestWith(['GreaterThan', '1970-01-01T00:00:00.000001Z', [[1_999, false, null, false]]])]
+    #[TestWith(['LessThan', '1969-12-31T23:59:59.999999Z', [[null, false, -1_000, false]]])]
+    #[TestWith(['Equal', '2300-01-01T00:00:00Z', []])]
+    #[TestWith(['LessThan', '2300-01-01T00:00:00Z', [[null, false, null, false]]])]
+    public function test_nanos_decode_floored_to_micros(string $operator, string $literal, array $expected): void
+    {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumnMother::timestamp(TimeUnit::NANOSECONDS),
+            OperatorMother::named($operator),
+            new DateTimeImmutable($literal),
+        ));
+    }
+
+    /**
+     * @param list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', '1970-01-01T00:00:00.0015Z', []])]
+    #[TestWith(['Equal', '1970-01-01T00:00:00.002Z', [[2, true, 2, true]]])]
+    #[TestWith(['GreaterThan', '1970-01-01T00:00:00.0015Z', [[1, false, null, false]]])]
+    #[TestWith(['GreaterThanOrEqual', '1970-01-01T00:00:00.0015Z', [[2, true, null, false]]])]
+    #[TestWith(['LessThanOrEqual', '1970-01-01T00:00:00.0015Z', [[null, false, 1, true]]])]
+    public function test_millis_hit_a_micros_literal_only_on_the_milli_grid(
+        string $operator,
+        string $literal,
+        array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumnMother::timestamp(TimeUnit::MILLISECONDS),
+            OperatorMother::named($operator),
+            new DateTimeImmutable($literal),
+        ));
+    }
+
+    public function test_micros_are_the_literal_itself(): void
+    {
+        static::assertSame(
+            [[1_500, true, 1_500, true]],
+            PhysicalIntervalEdges::ofComparison(
+                FlatColumn::dateTime('ts'),
+                Operator::Equal,
+                new DateTimeImmutable('1970-01-01T00:00:00.0015Z'),
+            ),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/UnsignedInt64PreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/UnsignedInt64PreImageTest.php
new file mode 100644
index 0000000000..6a56803551
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/UnsignedInt64PreImageTest.php
@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\OperatorMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use const PHP_INT_MIN;
+
+final class UnsignedInt64PreImageTest extends TestCase
+{
+    /**
+     * @param null|list<array{0: ?int, 1: bool, 2: ?int, 3: bool}> $expected
+     */
+    #[TestWith(['Equal', '18446744073709551615', [[-1, true, -1, true]]])]
+    #[TestWith(['Equal', 5, [[5, true, 5, true]]])]
+    #[TestWith(['LessThan', '9223372036854775808', [[null, false, PHP_INT_MIN, false]]])]
+    #[TestWith(['Equal', -1, []])]
+    #[TestWith(['GreaterThan', -1, [[null, false, null, false]]])]
+    #[TestWith(['LessThan', -1, []])]
+    #[TestWith(['Equal', '18446744073709551616', []])]
+    #[TestWith(['GreaterThan', '18446744073709551616', []])]
+    #[TestWith(['LessThan', '18446744073709551616', [[null, false, null, false]]])]
+    #[TestWith(['Equal', 1.0, [[1, true, 1, true]]])]
+    #[TestWith(['Equal', 2.5, []])]
+    #[TestWith(['GreaterThan', 2.5, [[2, false, null, false]]])]
+    #[TestWith(['LessThan', -0.5, [[null, false, 0, false]]])]
+    #[TestWith(['GreaterThan', -0.5, [[null, false, null, false]]])]
+    #[TestWith(['Equal', 1.0e20, null])]
+    public function test_uint64_binds_to_the_int64_bit_pattern(
+        string $operator,
+        float|int|string $literal,
+        ?array $expected,
+    ): void {
+        static::assertSame($expected, PhysicalIntervalEdges::ofComparison(
+            FlatColumnMother::uint64(),
+            OperatorMother::named($operator),
+            $literal,
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/UuidPreImageTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/UuidPreImageTest.php
new file mode 100644
index 0000000000..862f51e410
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Binding/PreImage/UuidPreImageTest.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Binding\PreImage;
+
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\PhysicalIntervalEdges;
+use PHPUnit\Framework\TestCase;
+
+use function hex2bin;
+
+final class UuidPreImageTest extends TestCase
+{
+    public function test_a_canonical_uuid_string_binds_to_its_16_bytes(): void
+    {
+        $bytes = hex2bin('f6d6e0e84b7e4b0e8d7aff0a0c9c9a5a');
+
+        static::assertSame(
+            [[$bytes, true, $bytes, true]],
+            PhysicalIntervalEdges::ofComparison(
+                FlatColumn::uuid('u'),
+                Operator::Equal,
+                'f6d6e0e8-4b7e-4b0e-8d7a-ff0a0c9c9a5a',
+            ),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/ColumnRefTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/ColumnRefTest.php
new file mode 100644
index 0000000000..3ebd4b6ff7
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/ColumnRefTest.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use DateTime;
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Comparison;
+use Flow\Parquet\Filter\In;
+use Flow\Parquet\Filter\IsNull;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Filter\Operator;
+use Flow\Parquet\Filter\StartsWith;
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class ColumnRefTest extends TestCase
+{
+    public function test_each_comparison_method_builds_its_operator(): void
+    {
+        $column = parquet_column('user.age');
+
+        static::assertEquals(new Comparison($column, Operator::Equal, 1), $column->equals(1));
+        static::assertEquals(new Comparison($column, Operator::LessThan, 1), $column->lessThan(1));
+        static::assertEquals(new Comparison($column, Operator::LessThanOrEqual, 1), $column->lessThanOrEqual(1));
+        static::assertEquals(new Comparison($column, Operator::GreaterThan, 1), $column->greaterThan(1));
+        static::assertEquals(new Comparison($column, Operator::GreaterThanOrEqual, 1), $column->greaterThanOrEqual(1));
+    }
+
+    public function test_the_negative_methods_negate_their_positive_node(): void
+    {
+        $column = parquet_column('id');
+
+        static::assertEquals(new Not($column->equals(1)), $column->notEquals(1));
+        static::assertEquals(new Not(new In($column, [1, 2])), $column->notIn([1, 2]));
+        static::assertEquals(new Not(new IsNull($column)), $column->isNotNull());
+    }
+
+    public function test_set_null_and_prefix_methods_build_their_leaf(): void
+    {
+        $column = parquet_column('name');
+
+        static::assertSame([1, 'a'], $column->in(['x' => 1, 'y' => 'a'])->values);
+        static::assertSame([], $column->in([])->values);
+        static::assertEquals(new IsNull($column), $column->isNull());
+        static::assertEquals(new StartsWith($column, 'ab'), $column->startsWith('ab'));
+    }
+
+    public function test_a_date_time_literal_is_stored_immutable(): void
+    {
+        $value = parquet_column('ts')->equals(new DateTime('2024-01-02 03:04:05.678901 UTC'))->value;
+
+        static::assertInstanceOf(DateTimeImmutable::class, $value);
+        static::assertSame('2024-01-02 03:04:05.678901', $value->format('Y-m-d H:i:s.u'));
+    }
+
+    public function test_an_empty_path_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A column path cannot be empty');
+
+        parquet_column('');
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/ComparisonTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/ComparisonTest.php
new file mode 100644
index 0000000000..a9d217ccb5
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/ComparisonTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class ComparisonTest extends TestCase
+{
+    public function test_it_visits_as_its_kind(): void
+    {
+        $leaf = parquet_column('id')->equals(1);
+
+        static::assertSame('comparison', $leaf->accept(new NodeNameVisitor()));
+    }
+
+    public function test_it_combines_and_negates(): void
+    {
+        $leaf = parquet_column('id')->equals(1);
+        $other = parquet_column('other')->isNull();
+
+        static::assertEquals(new All($leaf, $other), $leaf->and($other));
+        static::assertEquals(new Any($leaf, $other), $leaf->or($other));
+        static::assertEquals(new Not($leaf), $leaf->negate());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/BloomEvaluatorTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/BloomEvaluatorTest.php
new file mode 100644
index 0000000000..73d6b272d7
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/BloomEvaluatorTest.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\BloomTruth;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Mother\SbbfMother;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class BloomEvaluatorTest extends TestCase
+{
+    public function test_an_equality_whose_literal_is_absent_is_never(): void
+    {
+        static::assertSame(Truth::Never, BloomTruth::of(
+            parquet_column('i')->equals(4),
+            new InMemoryIndexes(bloomFilters: ['i' => [SbbfMother::with(FlatColumn::int64('i'), 1, 2, 3)]]),
+        ));
+        static::assertSame(Truth::Never, BloomTruth::of(
+            parquet_column('s')->equals('d'),
+            new InMemoryIndexes(bloomFilters: ['s' => [SbbfMother::with(FlatColumn::string('s'), 'a', 'b')]]),
+        ));
+    }
+
+    public function test_an_equality_whose_literal_is_present_is_maybe(): void
+    {
+        static::assertSame(Truth::Maybe, BloomTruth::of(
+            parquet_column('i')->equals(2),
+            new InMemoryIndexes(bloomFilters: ['i' => [SbbfMother::with(FlatColumn::int64('i'), 1, 2, 3)]]),
+        ));
+    }
+
+    public function test_in_is_never_only_when_every_literal_is_absent(): void
+    {
+        $indexes = new InMemoryIndexes(bloomFilters: ['i' => [SbbfMother::with(FlatColumn::int64('i'), 1, 2, 3)]]);
+
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->in([5, 3, 9]), $indexes));
+        static::assertSame(Truth::Never, BloomTruth::of(parquet_column('i')->in([5, 9]), $indexes));
+    }
+
+    public function test_a_negated_equality_is_maybe_and_reads_no_filter(): void
+    {
+        $indexes = new InMemoryIndexes(bloomFilters: ['i' => [SbbfMother::with(FlatColumn::int64('i'), 1)]]);
+
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->equals(4)->negate(), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->in([4, 5])->negate(), $indexes));
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_a_doubly_negated_equality_is_positive_again(): void
+    {
+        static::assertSame(Truth::Never, BloomTruth::of(
+            parquet_column('i')->equals(4)->negate()->negate(),
+            new InMemoryIndexes(bloomFilters: ['i' => [SbbfMother::with(FlatColumn::int64('i'), 1)]]),
+        ));
+    }
+
+    public function test_ranges_null_checks_and_prefixes_are_maybe_and_read_no_filter(): void
+    {
+        $indexes = new InMemoryIndexes(bloomFilters: [
+            'i' => [SbbfMother::with(FlatColumn::int64('i'), 1)],
+            's' => [SbbfMother::with(FlatColumn::string('s'), 'a')],
+        ]);
+
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->greaterThan(4), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->isNull(), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->isNotNull(), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('s')->startsWith('b'), $indexes));
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_an_equality_no_physical_value_satisfies_is_never_without_reading_a_filter(): void
+    {
+        $indexes = new InMemoryIndexes();
+
+        static::assertSame(Truth::Never, BloomTruth::of(parquet_column('i')->equals(1.5), $indexes));
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_a_chunk_without_a_filter_or_a_column_the_file_lacks_is_maybe(): void
+    {
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('i')->equals(4), new InMemoryIndexes()));
+        static::assertSame(Truth::Maybe, BloomTruth::of(parquet_column('missing')->equals(4), new InMemoryIndexes()));
+    }
+
+    public function test_a_zero_is_looked_up_with_both_signs(): void
+    {
+        static::assertSame(Truth::Maybe, BloomTruth::of(
+            parquet_column('f')->equals(0.0),
+            new InMemoryIndexes(bloomFilters: ['f' => [SbbfMother::with(FlatColumn::double('f'), -0.0)]]),
+        ));
+        static::assertSame(Truth::Maybe, BloomTruth::of(
+            parquet_column('f')->equals(-0.0),
+            new InMemoryIndexes(bloomFilters: ['f' => [SbbfMother::with(FlatColumn::double('f'), 0.0)]]),
+        ));
+        static::assertSame(Truth::Never, BloomTruth::of(
+            parquet_column('f')->equals(0.0),
+            new InMemoryIndexes(bloomFilters: ['f' => [SbbfMother::with(FlatColumn::double('f'), 1.5)]]),
+        ));
+    }
+
+    public function test_all_is_never_when_one_child_is_never_and_any_only_when_every_child_is(): void
+    {
+        $indexes = new InMemoryIndexes(bloomFilters: ['i' => [SbbfMother::with(FlatColumn::int64('i'), 1)]]);
+        $absent = parquet_column('i')->equals(4);
+        $present = parquet_column('i')->equals(1);
+
+        static::assertSame(Truth::Never, BloomTruth::of($present->and($absent), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of($present->or($absent), $indexes));
+        static::assertSame(Truth::Never, BloomTruth::of($absent->or(parquet_column('i')->equals(5)), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of($present->and($absent)->negate(), $indexes));
+        static::assertSame(Truth::Maybe, BloomTruth::of($present->or($absent)->negate(), $indexes));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/FilterEvaluatorTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/FilterEvaluatorTest.php
new file mode 100644
index 0000000000..6c0a50050b
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/FilterEvaluatorTest.php
@@ -0,0 +1,528 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use DateTimeImmutable;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\FilterEvaluator;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+use const INF;
+use const NAN;
+
+final class FilterEvaluatorTest extends TestCase
+{
+    public function test_a_comparison_on_null_is_null_and_so_is_its_negation(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('i'));
+        $batch = ['i' => [1, null, 2]];
+
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('i')->equals(1), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [2],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('i')->notEquals(1), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('i')->isNull(), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+    }
+
+    public function test_nan_equals_nothing_and_its_negation_holds(): void
+    {
+        $schema = Schema::with(FlatColumn::double('f'));
+        $batch = ['f' => [NAN, 1.0, -0.0, 7.0]];
+
+        static::assertSame(
+            [1, 2],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('f')->lessThan(5.0), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('f')->in([1.0, 9.0]), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [0, 3],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('f')->lessThan(5.0)->negate(),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [2],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('f')->equals(0.0), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+    }
+
+    public function test_strings_compare_in_byte_order_and_a_non_ascii_prefix_matches_bytes(): void
+    {
+        $schema = Schema::with(FlatColumn::string('s'));
+        $batch = ['s' => ['10', '9', 'a', 'źdźbło', 'zebra']];
+
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('s')->lessThan('9'), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [3],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('s')->startsWith('ź'),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+    }
+
+    public function test_unsigned_64_bit_values_compare_numerically_with_ints_digit_strings_and_floats(): void
+    {
+        $schema = Schema::with(FlatColumnMother::uint64());
+        $batch = ['u' => ['2', '10', '18446744073709551615']];
+
+        static::assertSame(
+            [1, 2],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('u')->greaterThan(9), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('u')->equals('10'), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('u')->lessThan(2.5), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('u')->greaterThan(1.0e19),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('u')->greaterThan(INF),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [0, 1, 2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('u')->greaterThan(-1),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+    }
+
+    public function test_a_float_on_an_integer_column_compares_numerically(): void
+    {
+        $schema = Schema::with(FlatColumn::int32('i'));
+
+        static::assertSame(
+            [1, 2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('i')->greaterThan(2.5),
+                $schema,
+                new Options(),
+            )))->mask(['i' => [
+                2,
+                3,
+                4,
+            ]]),
+        );
+    }
+
+    public function test_uuid_boolean_decimal_and_float32_columns_compare_their_decoded_values(): void
+    {
+        $schema = Schema::with(
+            FlatColumn::uuid('uid'),
+            FlatColumn::boolean('flag'),
+            FlatColumn::decimal('amount', 10, 2),
+            FlatColumn::float('ratio'),
+        );
+        $batch = [
+            'uid' => ['00000000-0000-4000-8000-000000000001', '00000000-0000-4000-8000-000000000002'],
+            'flag' => [true, false],
+            'amount' => [12.25, 3.5],
+            'ratio' => [20.5, 0.10000000149011612],
+        ];
+
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('uid')->greaterThan('00000000-0000-4000-8000-000000000001'),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('flag')->equals(false),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('amount')->equals(12.25),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('ratio')->equals(0.1),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('ratio')->equals(20.5),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+    }
+
+    public function test_an_uppercase_uuid_literal_matches_the_lowercase_value_it_names(): void
+    {
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('id')->in([
+                    '00000000-0000-4000-8000-0000000000AA',
+                    '00000000-0000-4000-8000-0000000000BB',
+                ]),
+                Schema::with(FlatColumn::uuid('id')),
+                new Options(),
+            )))->mask(['id' => ['00000000-0000-4000-8000-000000000001', '00000000-0000-4000-8000-0000000000aa']]),
+        );
+    }
+
+    public function test_a_mixed_in_matches_each_kind_numerically(): void
+    {
+        static::assertSame(
+            [0, 2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('i')->in([3, 33.0]),
+                Schema::with(FlatColumn::int64('i')),
+                new Options(),
+            )))->mask(['i' => [3, 4, 33]]),
+        );
+    }
+
+    public function test_an_in_orders_a_value_beyond_2_pow_53_against_literals_it_hashes(): void
+    {
+        static::assertSame(
+            [0, 2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('i')->in([(float) 2 ** 53, 5]),
+                Schema::with(FlatColumn::int64('i')),
+                new Options(),
+            )))->mask(['i' => [2 ** 53 + 1, 2 ** 53 + 3, 5]]),
+        );
+    }
+
+    public function test_an_in_matches_decoded_numbers_date_times_and_unsigned_64_bit_values_by_key(): void
+    {
+        static::assertSame(
+            [0, 2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('d')->in([1, 2.5]),
+                Schema::with(FlatColumn::double('d')),
+                new Options(),
+            )))->mask(['d' => [1.0, 2.0, 2.5, NAN]]),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('t')->in([new DateTimeImmutable('2024-01-01 02:00 +02:00')]),
+                Schema::with(FlatColumn::dateTime('t')),
+                new Options(),
+            )))->mask(['t' => [new DateTimeImmutable('2024-01-02 UTC'), new DateTimeImmutable('2024-01-01 UTC')]]),
+        );
+        static::assertSame(
+            [0, 2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('u')->in([2, '18446744073709551615']),
+                Schema::with(FlatColumnMother::uint64()),
+                new Options(),
+            )))->mask(['u' => ['2', '10', '18446744073709551615']]),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('u')->in([10.0]),
+                Schema::with(FlatColumnMother::uint64()),
+                new Options(),
+            )))->mask(['u' => ['2', '10']]),
+        );
+    }
+
+    public function test_date_times_compare_by_instant(): void
+    {
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('t')->equals(new DateTimeImmutable('2024-01-01 02:00 +02:00')),
+                Schema::with(FlatColumn::dateTime('t')),
+                new Options(),
+            )))->mask([
+                't' => [
+                    new DateTimeImmutable('2024-01-01 00:00 UTC'),
+                    new DateTimeImmutable('2024-01-01 00:00:01 UTC'),
+                ],
+            ]),
+        );
+    }
+
+    public function test_a_json_column_compares_its_text(): void
+    {
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('j')->startsWith('{"a"'),
+                Schema::with(FlatColumn::json('j')),
+                new Options(),
+            )))->mask(['j' => ['{"a": 1}', '[1]']]),
+        );
+    }
+
+    public function test_a_struct_leaf_is_read_through_its_struct_and_a_null_struct_holds_a_null_leaf(): void
+    {
+        $schema = Schema::with(NestedColumn::struct('address', [FlatColumn::string('city')]));
+        $batch = ['address' => [['city' => 'x'], null, ['city' => 'y']]];
+
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('address.city')->equals('x'),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('address.city')->isNull(),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+    }
+
+    public function test_a_column_the_file_lacks_is_null(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('i'));
+
+        static::assertSame(
+            [0, 1],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('missing')->isNull(),
+                $schema,
+                new Options(),
+            )))->mask(['i' => [1, 2]]),
+        );
+        static::assertSame(
+            [],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('missing')->equals(1),
+                $schema,
+                new Options(),
+            )))->mask(['i' => [1, 2]]),
+        );
+        static::assertSame(
+            [],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('missing')->notEquals(1),
+                $schema,
+                new Options(),
+            )))->mask(['i' => [
+                1,
+                2,
+            ]]),
+        );
+    }
+
+    public function test_composites_follow_three_valued_logic(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('i'), FlatColumn::int64('n'));
+        $batch = ['i' => [1, 1, 2], 'n' => [null, 1, null]];
+        $unknown = parquet_column('n')->equals(1);
+
+        static::assertSame(
+            [0, 1],
+            (new FilterEvaluator(BoundFilter::bind(
+                $unknown->or(parquet_column('i')->equals(1)),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [1],
+            (new FilterEvaluator(BoundFilter::bind(
+                $unknown->and(parquet_column('i')->equals(1)),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+        static::assertSame(
+            [0],
+            (new FilterEvaluator(BoundFilter::bind(
+                $unknown->and(parquet_column('i')->equals(2))->negate(),
+                $schema,
+                new Options(),
+            )))->mask(['i' => [1, 2], 'n' => [null, null]]),
+        );
+    }
+
+    public function test_in_and_starts_with_on_null_are_null(): void
+    {
+        $schema = Schema::with(FlatColumn::string('s'));
+        $batch = ['s' => [null, 'a', 'b']];
+
+        static::assertSame(
+            [2],
+            (new FilterEvaluator(BoundFilter::bind(parquet_column('s')->notIn(['a']), $schema, new Options())))->mask(
+                $batch,
+            ),
+        );
+        static::assertSame(
+            [2],
+            (new FilterEvaluator(BoundFilter::bind(
+                parquet_column('s')->startsWith('a')->negate(),
+                $schema,
+                new Options(),
+            )))->mask($batch),
+        );
+    }
+
+    public function test_the_roots_are_the_root_columns_of_the_present_leaves(): void
+    {
+        static::assertSame(
+            ['address', 'i'],
+            (new FilterEvaluator(BoundFilter::bind(
+                new All(
+                    parquet_column('address.city')->isNull(),
+                    parquet_column('i')->equals(1),
+                    parquet_column('missing')->isNull(),
+                ),
+                Schema::with(FlatColumn::int64('i'), NestedColumn::struct('address', [FlatColumn::string('city')])),
+                new Options(),
+            )))->roots(),
+        );
+    }
+
+    #[TestWith(['u', ' 9', 'Column "u" (INT64 (INTEGER)) cannot hold the string literal \' 9\''])]
+    #[TestWith(['u', '1e1', 'Column "u" (INT64 (INTEGER)) cannot hold the string literal \'1e1\''])]
+    #[TestWith(['u', '09', 'Column "u" (INT64 (INTEGER)) cannot hold the string literal \'09\''])]
+    #[TestWith(['i', '1', 'Column "i" (INT64) cannot hold the string literal \'1\''])]
+    #[TestWith(['b', 1, 'Column "b" (BOOLEAN) cannot hold the int literal 1'])]
+    #[TestWith([
+        't',
+        '2024-01-01',
+        'Column "t" (INT64 (TIMESTAMP)) cannot hold the string literal \'2024-01-01\'',
+    ])]
+    public function test_a_literal_the_column_cannot_hold_is_refused(
+        string $column,
+        int|string $literal,
+        string $message,
+    ): void {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($message);
+
+        new FilterEvaluator(BoundFilter::bind(
+            parquet_column($column)->equals($literal),
+            Schema::with(
+                FlatColumnMother::uint64(),
+                FlatColumn::int64('i'),
+                FlatColumn::boolean('b'),
+                FlatColumn::dateTime('t'),
+                FlatColumn::uuid('id'),
+            ),
+            new Options(),
+        ));
+    }
+
+    public function test_a_prefix_on_a_column_without_strings_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "i" (INT64) holds no strings for a prefix');
+
+        new FilterEvaluator(BoundFilter::bind(
+            parquet_column('i')->startsWith('1'),
+            Schema::with(FlatColumn::int64('i')),
+            new Options(),
+        ));
+    }
+
+    public function test_a_leaf_inside_a_list_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Filter column "tags.list.element" lies inside a list or a map, where a row holds no single value',
+        );
+
+        new FilterEvaluator(BoundFilter::bind(
+            parquet_column('tags.list.element')->equals('a'),
+            Schema::with(NestedColumn::list('tags', ListElement::string())),
+            new Options(),
+        ));
+    }
+
+    public function test_a_struct_column_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Filter column "address" is not a leaf column');
+
+        new FilterEvaluator(BoundFilter::bind(
+            parquet_column('address')->isNull(),
+            Schema::with(NestedColumn::struct('address', [FlatColumn::string('city')])),
+            new Options(),
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/PageZoneMapsAtRowTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/PageZoneMapsAtRowTest.php
new file mode 100644
index 0000000000..7f48daa519
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/PageZoneMapsAtRowTest.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use Flow\Parquet\Filter\Evaluation\PageZoneMaps;
+use Flow\Parquet\Filter\Evaluation\PageZoneMapsAtRow;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Mother\FooterMother;
+use Flow\Parquet\Tests\Mother\PageIndexMother;
+use PHPUnit\Framework\TestCase;
+
+final class PageZoneMapsAtRowTest extends TestCase
+{
+    public function test_a_view_answers_with_the_page_holding_its_row_and_shares_the_decoded_page(): void
+    {
+        $pages = new PageZoneMaps(
+            new MetadataRowGroupChunks(FooterMother::oneGroup(4, $a = FlatColumn::int64('a'))->metadata()),
+            ['a' => PageIndexMother::consistent(
+                PageIndexMother::int64([[0, 1], [2, 3]]),
+                PageIndexMother::pagesAt(0, 2),
+                4,
+            )],
+        );
+
+        static::assertSame(2, (new PageZoneMapsAtRow($pages, 3))->zone($a)?->min);
+        static::assertSame($pages->zone($a, 0), (new PageZoneMapsAtRow($pages, 1))->zone($a));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/PageZoneMapsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/PageZoneMapsTest.php
new file mode 100644
index 0000000000..6dedc28c79
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/PageZoneMapsTest.php
@@ -0,0 +1,140 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use Flow\Parquet\Filter\Evaluation\PageZoneMaps;
+use Flow\Parquet\Filter\Evaluation\ZoneMap;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\RowGroup;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Double\SpyFooter;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use Flow\Parquet\Tests\Mother\FooterMother;
+use Flow\Parquet\Tests\Mother\PageIndexMother;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+
+use const NAN;
+
+final class PageZoneMapsTest extends TestCase
+{
+    public function test_a_zone_is_the_page_holding_the_row_its_rows_ending_where_the_next_page_begins(): void
+    {
+        $chunks = new MetadataRowGroupChunks(FooterMother::oneGroup(10, $a = FlatColumn::int64('a'))->metadata());
+        $pageIndexes = ['a' => PageIndexMother::consistent(
+            PageIndexMother::int64([[0, 3], [4, 6], [7, 9]], [0, 1, 0]),
+            PageIndexMother::pagesAt(0, 4, 7),
+            10,
+        )];
+
+        $zones = new PageZoneMaps($chunks, $pageIndexes);
+
+        static::assertEquals(new ZoneMap(4, 6, true, true, 1, null, 3, false), $zones->at(5)->zone($a));
+        static::assertEquals(new ZoneMap(7, 9, true, true, 0, null, 3, false), $zones->at(9)->zone($a));
+    }
+
+    public function test_a_null_page_is_all_null_whatever_its_bounds_hold(): void
+    {
+        $chunks = new MetadataRowGroupChunks(FooterMother::oneGroup(10, $a = FlatColumn::int64('a'))->metadata());
+
+        $zones = new PageZoneMaps($chunks, ['a' => PageIndexMother::consistent(
+            PageIndexMother::int64([[0, 3], null], [0, 0]),
+            PageIndexMother::pagesAt(0, 4),
+            10,
+        )]);
+
+        static::assertEquals(new ZoneMap(null, null, true, true, 6, null, 6, false), $zones->at(4)->zone($a));
+    }
+
+    public function test_bytes_bounds_are_inexact(): void
+    {
+        $name = FlatColumn::string('name');
+        $chunks = new MetadataRowGroupChunks(FooterMother::oneGroup(4, $name)->metadata());
+
+        static::assertEquals(
+            new ZoneMap('a', 'b', false, false, 0, null, 4, false),
+            (new PageZoneMaps($chunks, ['name' => PageIndexMother::consistent(
+                new ColumnIndex([false], ['a'], ['b'], BoundaryOrder::ASCENDING, [0]),
+                PageIndexMother::pagesAt(0),
+                4,
+            )]))->at(0)->zone($name),
+        );
+    }
+
+    public function test_nan_counts_are_kept_and_nan_bounds_under_the_total_order_mean_every_value_is_nan(): void
+    {
+        $ratio = FlatColumn::double('ratio');
+        $chunks = new MetadataRowGroupChunks(
+            (new SpyFooter(
+                Schema::with($ratio),
+                4,
+                [new RowGroup([ColumnChunkMother::withStatistics($ratio, null)], 4)],
+                [ColumnOrder::Ieee754TotalOrder],
+            ))->metadata(),
+        );
+        $pageIndexes = ['ratio' => PageIndexMother::consistent(
+            new ColumnIndex(
+                [false, false],
+                [pack('e', 1.5), pack('e', NAN)],
+                [pack('e', 2.5), pack('e', NAN)],
+                BoundaryOrder::UNORDERED,
+                [0, 0],
+                [1, 2],
+            ),
+            PageIndexMother::pagesAt(0, 2),
+            4,
+        )];
+
+        static::assertEquals(
+            new ZoneMap(1.5, 2.5, true, true, 0, 1, 2, false),
+            (new PageZoneMaps($chunks, $pageIndexes))->at(0)->zone($ratio),
+        );
+        static::assertTrue((new PageZoneMaps($chunks, $pageIndexes))->at(3)->zone($ratio)?->allNaN);
+    }
+
+    public function test_bounds_an_order_does_not_trust_are_absent(): void
+    {
+        $a = FlatColumn::int64('a');
+        $chunks = new MetadataRowGroupChunks((new SpyFooter(Schema::with($a), 4, [new RowGroup(
+            [ColumnChunkMother::withStatistics($a, null)],
+            4,
+        )]))->metadata());
+
+        static::assertEquals(
+            new ZoneMap(null, null, true, true, 0, null, 4, false),
+            (new PageZoneMaps($chunks, ['a' => PageIndexMother::consistent(
+                PageIndexMother::int64([[0, 3]]),
+                PageIndexMother::pagesAt(0),
+                4,
+            )]))->at(0)->zone($a),
+        );
+    }
+
+    public function test_a_column_without_a_page_index_has_no_zone(): void
+    {
+        $chunks = new MetadataRowGroupChunks(FooterMother::oneGroup(4, $a = FlatColumn::int64('a'))->metadata());
+
+        static::assertNull((new PageZoneMaps($chunks, []))->at(0)->zone($a));
+    }
+
+    public function test_each_page_is_decoded_once(): void
+    {
+        $chunks = new MetadataRowGroupChunks(FooterMother::oneGroup(4, $a = FlatColumn::int64('a'))->metadata());
+        $zones = new PageZoneMaps($chunks, ['a' => PageIndexMother::consistent(
+            PageIndexMother::int64([[0, 1], [2, 3]]),
+            PageIndexMother::pagesAt(0, 2),
+            4,
+        )]);
+        $first = $zones->at(0)->zone($a);
+
+        static::assertNotSame($first, $zones->at(3)->zone($a));
+        static::assertSame($first, $zones->at(1)->zone($a));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/RowEvaluatorTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/RowEvaluatorTest.php
new file mode 100644
index 0000000000..663c59ae9a
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/RowEvaluatorTest.php
@@ -0,0 +1,392 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use DateTimeImmutable;
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\RowEvaluator;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\TimeUnit;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+use TypeError;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+use const NAN;
+
+final class RowEvaluatorTest extends TestCase
+{
+    /**
+     * @param 'lt'|'not lt'|'not not lt'|'any lt null'|'not all lt not null'|'not any lt null' $filter
+     */
+    #[TestWith(['lt', null, false])]
+    #[TestWith(['lt', 3, true])]
+    #[TestWith(['lt', 7, false])]
+    #[TestWith(['not lt', null, false])]
+    #[TestWith(['not lt', 3, false])]
+    #[TestWith(['not lt', 7, true])]
+    #[TestWith(['not not lt', null, false])]
+    #[TestWith(['not not lt', 3, true])]
+    #[TestWith(['any lt null', null, true])]
+    #[TestWith(['any lt null', 3, true])]
+    #[TestWith(['any lt null', 7, false])]
+    #[TestWith(['not all lt not null', null, true])]
+    #[TestWith(['not all lt not null', 3, false])]
+    #[TestWith(['not all lt not null', 7, true])]
+    #[TestWith(['not any lt null', null, false])]
+    #[TestWith(['not any lt null', 3, false])]
+    #[TestWith(['not any lt null', 7, true])]
+    public function test_a_null_is_true_under_neither_polarity(string $filter, ?int $value, bool $kept): void
+    {
+        $lt = parquet_column('i')->lessThan(5);
+        $null = parquet_column('i')->isNull();
+
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    match ($filter) {
+                        'lt' => $lt,
+                        'not lt' => $lt->negate(),
+                        'not not lt' => $lt->negate()->negate(),
+                        'any lt null' => $lt->or($null),
+                        'not all lt not null' => $lt->and($null->negate())->negate(),
+                        'not any lt null' => $lt->or($null)->negate(),
+                    },
+                    Schema::with(FlatColumn::int64('i')),
+                    new Options(),
+                ),
+                ['i' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    /**
+     * @param 'lt'|'not lt'|'not equals'|'not in' $filter
+     */
+    #[TestWith(['lt', NAN, false])]
+    #[TestWith(['lt', 3.0, true])]
+    #[TestWith(['lt', 5.0, false])]
+    #[TestWith(['lt', null, false])]
+    #[TestWith(['not lt', NAN, true])]
+    #[TestWith(['not lt', 3.0, false])]
+    #[TestWith(['not lt', 5.0, true])]
+    #[TestWith(['not lt', null, false])]
+    #[TestWith(['not equals', NAN, true])]
+    #[TestWith(['not equals', 5.0, false])]
+    #[TestWith(['not equals', 1.0, true])]
+    #[TestWith(['not equals', null, false])]
+    #[TestWith(['not in', NAN, true])]
+    #[TestWith(['not in', 1.0, false])]
+    #[TestWith(['not in', 3.0, true])]
+    #[TestWith(['not in', null, false])]
+    public function test_nan_compares_false_so_every_negation_keeps_it(string $filter, ?float $value, bool $kept): void
+    {
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    match ($filter) {
+                        'lt' => parquet_column('f')->lessThan(5.0),
+                        'not lt' => parquet_column('f')->lessThan(5.0)->negate(),
+                        'not equals' => parquet_column('f')->notEquals(5.0),
+                        'not in' => parquet_column('f')->notIn([1.0, 5.0]),
+                    },
+                    Schema::with(FlatColumn::double('f')),
+                    new Options(),
+                ),
+                ['f' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    /**
+     * @param 'f equals 0.0'|'f equals -0.0'|'f lt 0.0'|'f gte 0.0'|'r in -0.0'|'r gt -0.0' $filter
+     */
+    #[TestWith(['f equals 0.0', -0.0, true])]
+    #[TestWith(['f equals 0.0', 0.0, true])]
+    #[TestWith(['f equals -0.0', -0.0, true])]
+    #[TestWith(['f equals -0.0', 0.0, true])]
+    #[TestWith(['f lt 0.0', -0.0, false])]
+    #[TestWith(['f gte 0.0', -0.0, true])]
+    #[TestWith(['r in -0.0', 0.0, true])]
+    #[TestWith(['r gt -0.0', 0.0, false])]
+    public function test_negative_zero_equals_positive_zero(string $filter, float $value, bool $kept): void
+    {
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    match ($filter) {
+                        'f equals 0.0' => parquet_column('f')->equals(0.0),
+                        'f equals -0.0' => parquet_column('f')->equals(-0.0),
+                        'f lt 0.0' => parquet_column('f')->lessThan(0.0),
+                        'f gte 0.0' => parquet_column('f')->greaterThanOrEqual(0.0),
+                        'r in -0.0' => parquet_column('r')->in([-0.0]),
+                        'r gt -0.0' => parquet_column('r')->greaterThan(-0.0),
+                    },
+                    Schema::with(FlatColumn::double('f'), FlatColumn::float('r')),
+                    new Options(),
+                ),
+                ['f' => [$value], 'r' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    /**
+     * @param 'equals'|'lt'|'gt zero' $filter
+     */
+    #[TestWith(['equals', "\x04\xD2", true])]
+    #[TestWith(['equals', "\x04\xD1", false])]
+    #[TestWith(['lt', "\x04\xD2", false])]
+    #[TestWith(['lt', "\x04\xD1", true])]
+    #[TestWith(['lt', "\xFB\x2E", true])]
+    #[TestWith(['gt zero', "\x04\xD1", true])]
+    #[TestWith(['gt zero', "\xFB\x2E", false])]
+    public function test_decimal_unscaled_bytes_compare_as_signed_numbers(
+        string $filter,
+        string $value,
+        bool $kept,
+    ): void {
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    match ($filter) {
+                        'equals' => parquet_column('d')->equals(12.34),
+                        'lt' => parquet_column('d')->lessThan(12.34),
+                        'gt zero' => parquet_column('d')->greaterThan(0),
+                    },
+                    Schema::with(FlatColumnMother::flbaDecimal()),
+                    new Options(),
+                ),
+                ['d' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    /**
+     * @param 'equals'|'at most' $filter
+     */
+    #[TestWith(['equals', 999, false])]
+    #[TestWith(['equals', 1000, true])]
+    #[TestWith(['equals', 1999, true])]
+    #[TestWith(['equals', 2000, false])]
+    #[TestWith(['at most', 1999, true])]
+    #[TestWith(['at most', 2000, false])]
+    public function test_nanoseconds_match_the_microsecond_they_decode_to(string $filter, int $nanos, bool $kept): void
+    {
+        $microsecond = new DateTimeImmutable('1970-01-01 00:00:00.000001 UTC');
+
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    match ($filter) {
+                        'equals' => parquet_column('ts')->equals($microsecond),
+                        'at most' => parquet_column('ts')->lessThanOrEqual($microsecond),
+                    },
+                    Schema::with(FlatColumnMother::timestamp(TimeUnit::NANOSECONDS)),
+                    new Options(),
+                ),
+                ['ts' => [$nanos]],
+                1,
+            ),
+        );
+    }
+
+    #[TestWith([0, false])]
+    #[TestWith([1, true])]
+    #[TestWith([3, false])]
+    #[TestWith([5, true])]
+    #[TestWith([7, false])]
+    #[TestWith([9, true])]
+    #[TestWith([10, false])]
+    public function test_a_value_is_found_among_the_sorted_values_of_a_set(int $value, bool $kept): void
+    {
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    parquet_column('i')->in([9, 1, 5]),
+                    Schema::with(FlatColumn::int64('i')),
+                    new Options(),
+                ),
+                ['i' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    #[TestWith([-1, true])]
+    #[TestWith([5, false])]
+    public function test_an_unsigned_64_bit_pattern_compares_unsigned(int $bits, bool $greaterThanTen): void
+    {
+        static::assertSame(
+            [$greaterThanTen],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    parquet_column('u')->greaterThan(10),
+                    Schema::with(FlatColumnMother::uint64()),
+                    new Options(),
+                ),
+                ['u' => [$bits]],
+                1,
+            ),
+        );
+    }
+
+    /**
+     * @param 'is null'|'not is null'|'equals'|'not equals'|'not starts with' $filter
+     */
+    #[TestWith(['is null', true])]
+    #[TestWith(['not is null', false])]
+    #[TestWith(['equals', false])]
+    #[TestWith(['not equals', false])]
+    #[TestWith(['not starts with', false])]
+    public function test_an_absent_column_is_null_in_every_row(string $filter, bool $kept): void
+    {
+        static::assertSame(
+            [$kept, $kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    match ($filter) {
+                        'is null' => parquet_column('missing')->isNull(),
+                        'not is null' => parquet_column('missing')->isNull()->negate(),
+                        'equals' => parquet_column('missing')->equals(1),
+                        'not equals' => parquet_column('missing')->equals(1)->negate(),
+                        'not starts with' => parquet_column('missing')->startsWith('a')->negate(),
+                    },
+                    Schema::with(FlatColumn::int64('i')),
+                    new Options(),
+                ),
+                [],
+                2,
+            ),
+        );
+    }
+
+    #[TestWith(['', true])]
+    #[TestWith(['abc', true])]
+    #[TestWith([null, false])]
+    public function test_an_empty_prefix_starts_every_non_null_value(?string $value, bool $kept): void
+    {
+        $schema = Schema::with(FlatColumn::string('s'));
+
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(parquet_column('s')->startsWith(''), $schema, new Options()),
+                ['s' => [$value]],
+                1,
+            ),
+        );
+        static::assertSame(
+            [false],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(parquet_column('s')->startsWith('')->negate(), $schema, new Options()),
+                ['s' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    #[TestWith(["ab\x00", true])]
+    #[TestWith(['a', false])]
+    #[TestWith(['ba', false])]
+    public function test_a_prefix_compares_raw_bytes(string $value, bool $kept): void
+    {
+        static::assertSame(
+            [$kept],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(
+                    parquet_column('s')->startsWith('ab'),
+                    Schema::with(FlatColumn::string('s')),
+                    new Options(),
+                ),
+                ['s' => [$value]],
+                1,
+            ),
+        );
+    }
+
+    public function test_a_leaf_not_answered_exactly_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Rows are evaluated on leaves answered exactly, the leaf on "i" is not');
+
+        RowEvaluator::evaluate(
+            BoundFilter::bind(parquet_column('i')->equals('1'), Schema::with(FlatColumn::int64('i')), new Options()),
+            ['i' => [1]],
+            1,
+        );
+    }
+
+    public function test_is_null_is_true_on_a_null_row_and_is_not_null_on_a_value(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('i'));
+
+        static::assertSame(
+            [true, false, true],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(parquet_column('i')->isNull(), $schema, new Options()),
+                ['i' => [null, 3, null]],
+                3,
+            ),
+        );
+        static::assertSame(
+            [false, true, false],
+            RowEvaluator::evaluate(
+                BoundFilter::bind(parquet_column('i')->isNotNull(), $schema, new Options()),
+                ['i' => [null, 3, null]],
+                3,
+            ),
+        );
+    }
+
+    public function test_a_bound_column_without_values_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('No physical values of column "i"');
+
+        RowEvaluator::evaluate(
+            BoundFilter::bind(parquet_column('i')->isNull(), Schema::with(FlatColumn::int64('i')), new Options()),
+            [],
+            1,
+        );
+    }
+
+    public function test_values_for_another_row_count_are_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "i" holds 1 physical values for 2 rows');
+
+        RowEvaluator::evaluate(
+            BoundFilter::bind(parquet_column('i')->isNull(), Schema::with(FlatColumn::int64('i')), new Options()),
+            ['i' => [1]],
+            2,
+        );
+    }
+
+    public function test_a_value_that_is_no_physical_value_is_refused(): void
+    {
+        $this->expectException(TypeError::class);
+
+        RowEvaluator::evaluate(
+            BoundFilter::bind(parquet_column('i')->equals(1), Schema::with(FlatColumn::int64('i')), new Options()),
+            ['i' => [[1]]],
+            1,
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/RowGroupZoneMapsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/RowGroupZoneMapsTest.php
new file mode 100644
index 0000000000..fc774eb68a
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/RowGroupZoneMapsTest.php
@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use Flow\Parquet\Engine\Arrow\RustRowGroupChunks;
+use Flow\Parquet\Filter\Evaluation\RowGroupZoneMaps;
+use Flow\Parquet\Filter\Evaluation\ZoneMap;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Statistics;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Context\ThriftBytes;
+use Flow\Parquet\Tests\Double\RowGroupChunksSpy;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+
+use const NAN;
+
+final class RowGroupZoneMapsTest extends TestCase
+{
+    public function test_a_zone_is_the_chunk_statistics_under_the_column_order(): void
+    {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata();
+        $id = $metadata->schema()->getFlat('id');
+
+        static::assertEquals(
+            new ZoneMap(3, 4, true, true, 0, null, 2, false),
+            (new RowGroupZoneMaps(new MetadataRowGroupChunks($metadata), 1))->zone($id),
+        );
+    }
+
+    public function test_bounds_an_order_does_not_trust_are_absent(): void
+    {
+        $id = FlatColumn::int64('id');
+        $chunk = ColumnChunkMother::withStatistics(
+            $id,
+            new Statistics(null, null, 1, null, "\x01\x00\x00\x00\x00\x00\x00\x00", "\x01\x00\x00\x00\x00\x00\x00\x00"),
+        );
+
+        static::assertEquals(
+            new ZoneMap(null, null, true, true, 1, null, 2, false),
+            (new RowGroupZoneMaps(
+                RustRowGroupChunks::fromThrift([2], ['id' => [ThriftBytes::of($chunk->toThrift())]], ['id' => null]),
+                0,
+            ))->zone($id),
+        );
+    }
+
+    public function test_bytes_bounds_without_exactness_flags_are_inexact(): void
+    {
+        $name = FlatColumn::string('name');
+        $chunk = ColumnChunkMother::withStatistics($name, new Statistics(null, null, 0, null, 'b', 'a'));
+        $zone = (new RowGroupZoneMaps(
+            RustRowGroupChunks::fromThrift(
+                [2],
+                ['name' => [ThriftBytes::of($chunk->toThrift())]],
+                ['name' => ThriftBytes::of(ColumnOrder::TypeDefined->toThrift())],
+            ),
+            0,
+        ))->zone($name);
+
+        static::assertEquals(new ZoneMap('a', 'b', false, false, 0, null, 2, false), $zone);
+    }
+
+    public function test_a_chunk_without_statistics_has_no_zone(): void
+    {
+        $id = FlatColumn::int64('id');
+        $chunk = ColumnChunkMother::withStatistics($id, null);
+
+        static::assertNull((new RowGroupZoneMaps(
+            RustRowGroupChunks::fromThrift([2], ['id' => [ThriftBytes::of($chunk->toThrift())]], ['id' => null]),
+            0,
+        ))->zone($id));
+    }
+
+    public function test_deprecated_bounds_are_never_used_even_under_a_trusted_order(): void
+    {
+        $name = FlatColumn::string('name');
+        $chunk = ColumnChunkMother::withStatistics($name, new Statistics('z', 'a', 0, null, null, null));
+
+        static::assertEquals(
+            new ZoneMap(null, null, false, false, 0, null, 2, false),
+            (new RowGroupZoneMaps(
+                RustRowGroupChunks::fromThrift(
+                    [2],
+                    ['name' => [ThriftBytes::of($chunk->toThrift())]],
+                    ['name' => ThriftBytes::of(ColumnOrder::TypeDefined->toThrift())],
+                ),
+                0,
+            ))->zone($name),
+        );
+    }
+
+    public function test_a_nan_bound_under_total_order_makes_the_zone_all_nan(): void
+    {
+        $score = FlatColumn::double('score');
+        $chunk = ColumnChunkMother::withStatistics(
+            $score,
+            new Statistics(null, null, 0, null, pack('e', NAN), pack('e', NAN), nanCount: 2),
+        );
+        $chunks = static fn(ColumnOrder $order): RustRowGroupChunks => RustRowGroupChunks::fromThrift(
+            [2],
+            ['score' => [ThriftBytes::of($chunk->toThrift())]],
+            ['score' => ThriftBytes::of($order->toThrift())],
+        );
+
+        static::assertTrue((new RowGroupZoneMaps($chunks(ColumnOrder::Ieee754TotalOrder), 0))->zone($score)?->allNaN);
+        static::assertEquals(
+            new ZoneMap(null, null, true, true, 0, 2, 2, false),
+            (new RowGroupZoneMaps($chunks(ColumnOrder::TypeDefined), 0))->zone($score),
+        );
+    }
+
+    public function test_a_zone_is_decoded_once_per_column(): void
+    {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata();
+        $chunks = new RowGroupChunksSpy(new MetadataRowGroupChunks($metadata));
+        $zones = new RowGroupZoneMaps($chunks, 2);
+
+        static::assertSame(
+            $zones->zone($metadata->schema()->getFlat('id')),
+            $zones->zone($metadata->schema()->getFlat('id')),
+        );
+        static::assertSame([2], $chunks->chunkReads);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/StatisticsEvaluatorTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/StatisticsEvaluatorTest.php
new file mode 100644
index 0000000000..2446e10022
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/Evaluation/StatisticsEvaluatorTest.php
@@ -0,0 +1,413 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter\Evaluation;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Truth;
+use Flow\Parquet\Tests\Context\ZoneTruth;
+use Flow\Parquet\Tests\Mother\ZoneMapMother;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+use const INF;
+
+final class StatisticsEvaluatorTest extends TestCase
+{
+    public function test_comparison_positive_never_when_all_null_or_the_bounds_miss_the_interval(): void
+    {
+        $lt = parquet_column('i')->lessThan(5);
+
+        static::assertSame(Truth::Never, ZoneTruth::of($lt, ['i' => ZoneMapMother::allNull()]));
+        static::assertSame(Truth::Never, ZoneTruth::of($lt, ['i' => ZoneMapMother::withNulls(5, 9)]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($lt, ['i' => ZoneMapMother::withNulls(4, 9)]));
+    }
+
+    public function test_comparison_positive_always_when_no_null_and_the_interval_holds_the_bounds(): void
+    {
+        $lt = parquet_column('i')->lessThan(5);
+
+        static::assertSame(Truth::Always, ZoneTruth::of($lt, ['i' => ZoneMapMother::clean(1, 4)]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($lt, ['i' => ZoneMapMother::withNulls(1, 4)]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($lt, ['i' => ZoneMapMother::unknownNulls(1, 4)]));
+    }
+
+    public function test_comparison_negated_never_when_all_null_or_every_value_matches(): void
+    {
+        $notLt = parquet_column('i')->lessThan(5)->negate();
+
+        static::assertSame(Truth::Never, ZoneTruth::of($notLt, ['i' => ZoneMapMother::allNull()]));
+        static::assertSame(Truth::Never, ZoneTruth::of($notLt, ['i' => ZoneMapMother::withNulls(1, 4)]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notLt, ['i' => ZoneMapMother::withNulls(1, 5)]));
+    }
+
+    public function test_comparison_negated_always_when_no_null_and_the_bounds_miss_the_interval(): void
+    {
+        $notLt = parquet_column('i')->lessThan(5)->negate();
+
+        static::assertSame(Truth::Always, ZoneTruth::of($notLt, ['i' => ZoneMapMother::clean(5, 9)]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notLt, ['i' => ZoneMapMother::withNulls(5, 9)]));
+    }
+
+    public function test_in_is_the_union_of_its_equalities(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->in([1, 9]), ['i' => ZoneMapMother::clean(
+            3,
+            7,
+        )]));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('i')->in([3]), ['i' => ZoneMapMother::clean(
+            3,
+            3,
+        )]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->in([3, 9]), ['i' => ZoneMapMother::clean(
+            3,
+            7,
+        )]));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->notIn([3]), ['i' => ZoneMapMother::clean(
+            3,
+            3,
+        )]));
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('i')->notIn([1, 9]),
+            ['i' => ZoneMapMother::clean(3, 7)],
+        ));
+    }
+
+    public function test_an_empty_in_never_matches_and_its_negation_follows_the_nulls(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->in([]), ['i' => ZoneMapMother::clean(
+            1,
+            4,
+        )]));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->in([]), []));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('i')->notIn([]), ['i' => ZoneMapMother::clean(
+            1,
+            4,
+        )]));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->notIn([]), [
+            'i' => ZoneMapMother::allNull(),
+        ]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->notIn([]), ['i' => ZoneMapMother::withNulls(
+            1,
+            4,
+        )]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->notIn([]), []));
+    }
+
+    public function test_is_null_positive_never_without_nulls_and_always_when_all_null(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->isNull(), ['i' => ZoneMapMother::clean(
+            1,
+            4,
+        )]));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('i')->isNull(), [
+            'i' => ZoneMapMother::allNull(),
+        ]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->isNull(), ['i' => ZoneMapMother::withNulls(
+            1,
+            4,
+        )]));
+    }
+
+    public function test_is_null_negated_never_when_all_null_and_always_without_nulls(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->isNotNull(), [
+            'i' => ZoneMapMother::allNull(),
+        ]));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('i')->isNotNull(), ['i' => ZoneMapMother::clean(
+            1,
+            4,
+        )]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('i')->isNotNull(),
+            ['i' => ZoneMapMother::withNulls(1, 4)],
+        ));
+    }
+
+    public function test_an_unknown_null_count_gives_maybe_for_is_null(): void
+    {
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('i')->isNull(),
+            ['i' => ZoneMapMother::unknownNulls(1, 4)],
+        ));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('i')->isNotNull(),
+            ['i' => ZoneMapMother::unknownNulls(1, 4)],
+        ));
+    }
+
+    public function test_is_null_needs_no_trusted_bound(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('i')->isNull(), [
+            'i' => ZoneMapMother::untrusted(),
+        ]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->lessThan(5), [
+            'i' => ZoneMapMother::untrusted(),
+        ]));
+    }
+
+    public function test_starts_with_positive_never_when_all_null_or_the_bounds_miss_the_prefix(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('s')->startsWith('b'), [
+            's' => ZoneMapMother::allNull(),
+        ]));
+        static::assertSame(Truth::Never, ZoneTruth::of(
+            parquet_column('s')->startsWith('b'),
+            ['s' => ZoneMapMother::withNulls('c', 'd')],
+        ));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('s')->startsWith('b'),
+            ['s' => ZoneMapMother::withNulls('a', 'c')],
+        ));
+    }
+
+    public function test_starts_with_positive_always_when_both_bounds_start_with_the_prefix(): void
+    {
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('s')->startsWith('ab'),
+            ['s' => ZoneMapMother::clean('ab', 'abz')],
+        ));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('s')->startsWith('ab'),
+            ['s' => ZoneMapMother::withNulls('ab', 'abz')],
+        ));
+    }
+
+    public function test_starts_with_negated_never_when_all_null_or_both_bounds_start_with_the_prefix(): void
+    {
+        $notPrefix = parquet_column('s')->startsWith('ab')->negate();
+
+        static::assertSame(Truth::Never, ZoneTruth::of($notPrefix, ['s' => ZoneMapMother::allNull()]));
+        static::assertSame(Truth::Never, ZoneTruth::of($notPrefix, ['s' => ZoneMapMother::withNulls('ab', 'abz')]));
+    }
+
+    public function test_starts_with_negated_always_when_no_null_and_the_bounds_miss_the_prefix(): void
+    {
+        $notPrefix = parquet_column('s')->startsWith('ab')->negate();
+
+        static::assertSame(Truth::Always, ZoneTruth::of($notPrefix, ['s' => ZoneMapMother::clean('b', 'c')]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notPrefix, ['s' => ZoneMapMother::withNulls('b', 'c')]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notPrefix, ['s' => ZoneMapMother::untrusted()]));
+    }
+
+    public function test_an_empty_prefix_matches_every_value_that_is_not_null(): void
+    {
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('s')->startsWith(''),
+            ['s' => ZoneMapMother::clean('', "\xFF")],
+        ));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('s')->startsWith(''),
+            ['s' => ZoneMapMother::withNulls('a', 'b')],
+        ));
+    }
+
+    public function test_an_all_0xff_prefix_has_no_upper_bound(): void
+    {
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('s')->startsWith("\xFF"),
+            ['s' => ZoneMapMother::clean("\xFF", "\xFF\xFF")],
+        ));
+        static::assertSame(Truth::Never, ZoneTruth::of(
+            parquet_column('s')->startsWith("\xFF"),
+            ['s' => ZoneMapMother::clean('a', "\xFE")],
+        ));
+    }
+
+    public function test_all_is_never_with_any_never_and_always_with_all_always(): void
+    {
+        $zones = ['i' => ZoneMapMother::clean(1, 4), 's' => ZoneMapMother::withNulls('a', 'b')];
+
+        static::assertSame(Truth::Never, ZoneTruth::of(
+            parquet_column('i')->lessThan(5)->and(parquet_column('i')->greaterThan(9)),
+            $zones,
+        ));
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('i')->lessThan(5)->and(parquet_column('i')->greaterThan(0)),
+            $zones,
+        ));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('i')->lessThan(5)->and(parquet_column('s')->equals('a')),
+            $zones,
+        ));
+        static::assertSame(Truth::Always, ZoneTruth::of(new All(), $zones));
+    }
+
+    public function test_any_is_never_with_all_never_and_always_with_any_always(): void
+    {
+        $zones = ['i' => ZoneMapMother::clean(1, 4), 's' => ZoneMapMother::withNulls('a', 'b')];
+
+        static::assertSame(Truth::Never, ZoneTruth::of(
+            parquet_column('i')->greaterThan(5)->or(parquet_column('i')->lessThan(0)),
+            $zones,
+        ));
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('s')->equals('a')->or(parquet_column('i')->lessThan(5)),
+            $zones,
+        ));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('i')->greaterThan(5)->or(parquet_column('s')->equals('a')),
+            $zones,
+        ));
+        static::assertSame(Truth::Never, ZoneTruth::of(new Any(), $zones));
+    }
+
+    public function test_a_negated_all_is_the_any_of_its_negated_children(): void
+    {
+        $zones = ['i' => ZoneMapMother::clean(1, 4)];
+
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('i')->lessThan(5)->and(parquet_column('i')->greaterThan(9))->negate(),
+            $zones,
+        ));
+        static::assertSame(Truth::Never, ZoneTruth::of(
+            parquet_column('i')->lessThan(5)->and(parquet_column('i')->greaterThan(0))->negate(),
+            $zones,
+        ));
+    }
+
+    public function test_a_negated_any_is_the_all_of_its_negated_children(): void
+    {
+        $zones = ['i' => ZoneMapMother::clean(1, 4)];
+
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('i')->greaterThan(5)->or(parquet_column('i')->lessThan(0))->negate(),
+            $zones,
+        ));
+        static::assertSame(Truth::Never, ZoneTruth::of(
+            parquet_column('i')->greaterThan(5)->or(parquet_column('i')->lessThan(5))->negate(),
+            $zones,
+        ));
+    }
+
+    public function test_a_double_negation_is_the_child(): void
+    {
+        $zones = ['i' => ZoneMapMother::clean(1, 4)];
+
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('i')->lessThan(5)->negate()->negate(), $zones));
+    }
+
+    public function test_an_all_nan_zone_never_matches_and_its_negation_follows_the_nulls(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('f')->lessThan(5.0), [
+            'f' => ZoneMapMother::allNaN(),
+        ]));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('f')->lessThan(5.0)->negate(), [
+            'f' => ZoneMapMother::allNaN(),
+        ]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('f')->lessThan(5.0)->negate(), [
+            'f' => ZoneMapMother::allNaN(2),
+        ]));
+    }
+
+    public function test_an_infinity_bound_is_a_value_of_the_zone(): void
+    {
+        $toInfinity = ['f' => ZoneMapMother::ieee(1.0, INF, nanCount: 0)];
+
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('f')->equals(INF), $toInfinity));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('f')->greaterThanOrEqual(INF), $toInfinity));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('f')->equals(INF)->negate(), $toInfinity));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('f')->greaterThan(-INF), [
+            'f' => ZoneMapMother::ieee(-INF, 1.0, nanCount: 0),
+        ]));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('f')->equals(INF)->negate(), [
+            'f' => ZoneMapMother::ieee(INF, INF, nanCount: 0),
+        ]));
+    }
+
+    public function test_not_less_than_needs_no_nan_to_be_never(): void
+    {
+        $notLt = parquet_column('f')->lessThan(5.0)->negate();
+
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notLt, ['f' => ZoneMapMother::unknownNaN(1.0, 4.0)]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notLt, ['f' => ZoneMapMother::ieee(1.0, 4.0, nanCount: 1)]));
+        static::assertSame(Truth::Never, ZoneTruth::of($notLt, ['f' => ZoneMapMother::ieee(1.0, 4.0, nanCount: 0)]));
+    }
+
+    public function test_not_equals_needs_no_nan_to_be_never(): void
+    {
+        $notEquals = parquet_column('f')->notEquals(3.0);
+
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notEquals, ['f' => ZoneMapMother::unknownNaN(3.0, 3.0)]));
+        static::assertSame(Truth::Never, ZoneTruth::of($notEquals, ['f' => ZoneMapMother::ieee(
+            3.0,
+            3.0,
+            nanCount: 0,
+        )]));
+    }
+
+    public function test_not_in_needs_no_nan_to_be_never(): void
+    {
+        $notIn = parquet_column('f')->notIn([3.0, 4.0]);
+
+        static::assertSame(Truth::Maybe, ZoneTruth::of($notIn, ['f' => ZoneMapMother::unknownNaN(3.0, 3.0)]));
+        static::assertSame(Truth::Never, ZoneTruth::of($notIn, ['f' => ZoneMapMother::ieee(3.0, 3.0, nanCount: 0)]));
+    }
+
+    public function test_a_float_comparison_is_always_only_without_nan(): void
+    {
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('f')->lessThan(5.0),
+            ['f' => ZoneMapMother::unknownNaN(1.0, 4.0)],
+        ));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('f')->lessThan(5.0), ['f' => ZoneMapMother::ieee(
+            1.0,
+            4.0,
+            nanCount: 0,
+        )]));
+    }
+
+    public function test_inexact_bounds_never_prove_an_equality(): void
+    {
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('s')->equals('ab'),
+            ['s' => ZoneMapMother::inexact('ab', 'ab')],
+        ));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('s')->equals('ab'), ['s' => ZoneMapMother::clean(
+            'ab',
+            'ab',
+        )]));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(
+            parquet_column('s')->notEquals('ab'),
+            ['s' => ZoneMapMother::inexact('ab', 'ab')],
+        ));
+        static::assertSame(Truth::Always, ZoneTruth::of(
+            parquet_column('s')->lessThan('b'),
+            ['s' => ZoneMapMother::inexact('aa', 'ab')],
+        ));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('s')->equals('b'), ['s' => ZoneMapMother::inexact(
+            'aa',
+            'ab',
+        )]));
+    }
+
+    public function test_an_unbound_leaf_is_maybe_in_both_polarities(): void
+    {
+        $zones = ['i' => ZoneMapMother::clean(1, 4)];
+
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->equals('1'), $zones));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->notEquals('1'), $zones));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->startsWith('1')->negate(), $zones));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->startsWith('1'), $zones));
+    }
+
+    public function test_an_absent_column_is_an_all_null_zone(): void
+    {
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('missing')->equals(1), []));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('missing')->notEquals(1), []));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('missing')->startsWith('a'), []));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('missing')->startsWith('a')->negate(), []));
+        static::assertSame(Truth::Always, ZoneTruth::of(parquet_column('missing')->isNull(), []));
+        static::assertSame(Truth::Never, ZoneTruth::of(parquet_column('missing')->isNotNull(), []));
+    }
+
+    public function test_a_column_without_usable_statistics_is_maybe(): void
+    {
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->lessThan(5), []));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('i')->isNull(), []));
+        static::assertSame(Truth::Maybe, ZoneTruth::of(parquet_column('s')->startsWith('a'), []));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/InTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/InTest.php
new file mode 100644
index 0000000000..0ce6ea919d
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/InTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class InTest extends TestCase
+{
+    public function test_it_visits_as_its_kind(): void
+    {
+        $leaf = parquet_column('id')->in([1]);
+
+        static::assertSame('in', $leaf->accept(new NodeNameVisitor()));
+    }
+
+    public function test_it_combines_and_negates(): void
+    {
+        $leaf = parquet_column('id')->in([1]);
+        $other = parquet_column('other')->isNull();
+
+        static::assertEquals(new All($leaf, $other), $leaf->and($other));
+        static::assertEquals(new Any($leaf, $other), $leaf->or($other));
+        static::assertEquals(new Not($leaf), $leaf->negate());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/IsNullTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/IsNullTest.php
new file mode 100644
index 0000000000..e794194254
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/IsNullTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class IsNullTest extends TestCase
+{
+    public function test_it_visits_as_its_kind(): void
+    {
+        $leaf = parquet_column('id')->isNull();
+
+        static::assertSame('isNull', $leaf->accept(new NodeNameVisitor()));
+    }
+
+    public function test_it_combines_and_negates(): void
+    {
+        $leaf = parquet_column('id')->isNull();
+        $other = parquet_column('other')->isNull();
+
+        static::assertEquals(new All($leaf, $other), $leaf->and($other));
+        static::assertEquals(new Any($leaf, $other), $leaf->or($other));
+        static::assertEquals(new Not($leaf), $leaf->negate());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/LiteralTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/LiteralTest.php
new file mode 100644
index 0000000000..af945d7f50
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/LiteralTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use DateTimeImmutable;
+use Flow\Parquet\Filter\Literal;
+use Flow\Parquet\Tests\Double\StringableUuid;
+use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use const INF;
+
+final class LiteralTest extends TestCase
+{
+    #[TestWith([1])]
+    #[TestWith([1.5])]
+    #[TestWith([INF])]
+    #[TestWith(['a'])]
+    #[TestWith([true])]
+    public function test_a_scalar_is_kept_as_it_is(bool|float|int|string $value): void
+    {
+        static::assertSame($value, Literal::of($value));
+    }
+
+    public function test_a_stringable_is_kept_as_its_string(): void
+    {
+        static::assertSame(
+            'f6d6e0e8-4b7e-4b0e-8d7a-ff0a0c9c9a5a',
+            Literal::of(new StringableUuid('f6d6e0e8-4b7e-4b0e-8d7a-ff0a0c9c9a5a')),
+        );
+    }
+
+    public function test_an_immutable_date_time_is_kept_equal(): void
+    {
+        $date = new DateTimeImmutable('2024-01-01 00:00:00 UTC');
+
+        static::assertEquals($date, Literal::of($date));
+    }
+
+    public function test_another_kind_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'A filter literal must be a scalar, a DateTimeInterface or a Stringable, array given',
+        );
+
+        Literal::of([1]);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/NotTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/NotTest.php
new file mode 100644
index 0000000000..dce23a1296
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/NotTest.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+use const NAN;
+
+final class NotTest extends TestCase
+{
+    public function test_negating_twice_returns_the_child(): void
+    {
+        $child = parquet_column('id')->lessThan(5);
+
+        static::assertSame($child, $child->negate()->negate());
+        static::assertSame($child, (new Not($child))->negate());
+    }
+
+    public function test_a_not_visits_as_a_not(): void
+    {
+        $not = parquet_column('id')->lessThan(5)->negate();
+
+        static::assertSame('not', $not->accept(new NodeNameVisitor()));
+        static::assertEquals(new All($not, parquet_column('a')->isNull()), $not->and(parquet_column('a')->isNull()));
+        static::assertEquals(new Any($not, parquet_column('a')->isNull()), $not->or(parquet_column('a')->isNull()));
+    }
+
+    public function test_a_null_literal_is_refused_in_favour_of_is_null(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A filter literal cannot be null, use isNull()');
+
+        parquet_column('id')->notEquals(null);
+    }
+
+    #[TestWith([NAN])]
+    public function test_a_nan_literal_is_refused(float $nan): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A filter literal cannot be NaN');
+
+        parquet_column('score')->notIn([1.0, $nan]);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/StartsWithTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/StartsWithTest.php
new file mode 100644
index 0000000000..7b69e3e962
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/StartsWithTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Any;
+use Flow\Parquet\Filter\Not;
+use Flow\Parquet\Tests\Double\NodeNameVisitor;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class StartsWithTest extends TestCase
+{
+    public function test_it_visits_as_its_kind(): void
+    {
+        $leaf = parquet_column('id')->startsWith('a');
+
+        static::assertSame('startsWith', $leaf->accept(new NodeNameVisitor()));
+    }
+
+    public function test_it_combines_and_negates(): void
+    {
+        $leaf = parquet_column('id')->startsWith('a');
+        $other = parquet_column('other')->isNull();
+
+        static::assertEquals(new All($leaf, $other), $leaf->and($other));
+        static::assertEquals(new Any($leaf, $other), $leaf->or($other));
+        static::assertEquals(new Not($leaf), $leaf->negate());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/TruthTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/TruthTest.php
new file mode 100644
index 0000000000..d3b759a5ea
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Filter/TruthTest.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Filter;
+
+use Flow\Parquet\Filter\Truth;
+use Generator;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+
+final class TruthTest extends TestCase
+{
+    public function test_every_is_never_when_one_is_never_and_always_only_when_all_are(): void
+    {
+        static::assertSame(Truth::Always, Truth::every([]));
+        static::assertSame(Truth::Always, Truth::every([Truth::Always, Truth::Always]));
+        static::assertSame(Truth::Maybe, Truth::every([Truth::Always, Truth::Maybe]));
+        static::assertSame(Truth::Never, Truth::every([Truth::Maybe, Truth::Never]));
+    }
+
+    public function test_some_is_always_when_one_is_always_and_never_only_when_all_are(): void
+    {
+        static::assertSame(Truth::Never, Truth::some([]));
+        static::assertSame(Truth::Never, Truth::some([Truth::Never, Truth::Never]));
+        static::assertSame(Truth::Maybe, Truth::some([Truth::Never, Truth::Maybe]));
+        static::assertSame(Truth::Always, Truth::some([Truth::Maybe, Truth::Always]));
+    }
+
+    public function test_both_stop_at_the_deciding_truth(): void
+    {
+        $never = (
+            /** @return Generator<int, Truth> */
+            static function (): Generator {
+                yield Truth::Maybe;
+                yield Truth::Never;
+
+                throw new RuntimeException('evaluated past the deciding truth');
+            }
+        )();
+        $always = (
+            /** @return Generator<int, Truth> */
+            static function (): Generator {
+                yield Truth::Maybe;
+                yield Truth::Always;
+
+                throw new RuntimeException('evaluated past the deciding truth');
+            }
+        )();
+
+        static::assertSame(Truth::Never, Truth::every($never));
+        static::assertSame(Truth::Always, Truth::some($always));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/ColumnOrderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/ColumnOrderTest.php
new file mode 100644
index 0000000000..d2872fec23
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/ColumnOrderTest.php
@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\ThriftModel\ColumnOrder as ThriftColumnOrder;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function var_export;
+
+use const NAN;
+
+final class ColumnOrderTest extends TestCase
+{
+    /**
+     * @return Generator<string, array{FlatColumn, ColumnOrder}>
+     */
+    public static function writing(): Generator
+    {
+        yield 'float' => [FlatColumn::float('f'), ColumnOrder::Ieee754TotalOrder];
+        yield 'double' => [FlatColumn::double('d'), ColumnOrder::Ieee754TotalOrder];
+        yield 'float16' => [FlatColumnMother::float16(), ColumnOrder::Ieee754TotalOrder];
+        yield 'int96' => [FlatColumnMother::int96(), ColumnOrder::Int96Timestamp];
+        yield 'string' => [FlatColumn::string('s'), ColumnOrder::TypeDefined];
+        yield 'int64' => [FlatColumn::int64('i'), ColumnOrder::TypeDefined];
+        yield 'decimal' => [FlatColumnMother::flbaDecimal(), ColumnOrder::TypeDefined];
+        yield 'boolean' => [FlatColumn::boolean('b'), ColumnOrder::TypeDefined];
+    }
+
+    #[DataProvider('writing')]
+    public function test_for_writing(FlatColumn $column, ColumnOrder $expected): void
+    {
+        static::assertSame($expected, ColumnOrder::forWriting($column));
+    }
+
+    public function test_from_thrift_without_column_orders_is_absent(): void
+    {
+        static::assertSame(ColumnOrder::Absent, ColumnOrder::fromThrift(null));
+    }
+
+    public function test_from_thrift_without_a_known_member_is_unknown(): void
+    {
+        static::assertSame(ColumnOrder::Unknown, ColumnOrder::fromThrift(new ThriftColumnOrder()));
+    }
+
+    #[TestWith([ColumnOrder::TypeDefined])]
+    #[TestWith([ColumnOrder::Ieee754TotalOrder])]
+    #[TestWith([ColumnOrder::Int96Timestamp])]
+    #[TestWith([ColumnOrder::Unknown])]
+    public function test_thrift_round_trip(ColumnOrder $order): void
+    {
+        static::assertSame($order, ColumnOrder::fromThrift($order->toThrift()));
+    }
+
+    public function test_absent_cannot_be_written(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column order Absent cannot be written');
+
+        ColumnOrder::Absent->toThrift();
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, ColumnOrder, bool}>
+     */
+    public static function trust(): Generator
+    {
+        yield 'string type defined' => [FlatColumn::string('s'), ColumnOrder::TypeDefined, true];
+        yield 'double total order' => [FlatColumn::double('d'), ColumnOrder::Ieee754TotalOrder, true];
+        yield 'string absent' => [FlatColumn::string('s'), ColumnOrder::Absent, false];
+        yield 'double absent' => [FlatColumn::double('d'), ColumnOrder::Absent, false];
+        yield 'flba decimal absent' => [FlatColumnMother::flbaDecimal(), ColumnOrder::Absent, false];
+        yield 'int32 absent' => [FlatColumn::int32('i'), ColumnOrder::Absent, false];
+        yield 'int64 absent' => [FlatColumn::int64('i'), ColumnOrder::Absent, false];
+        yield 'date absent' => [FlatColumn::date('d'), ColumnOrder::Absent, false];
+        yield 'timestamp absent' => [FlatColumn::dateTime('t'), ColumnOrder::Absent, false];
+        yield 'uint64 absent' => [FlatColumnMother::uint64(), ColumnOrder::Absent, false];
+        yield 'uint32 absent' => [FlatColumnMother::uint32(), ColumnOrder::Absent, false];
+        yield 'uint64 type defined' => [FlatColumnMother::uint64(), ColumnOrder::TypeDefined, true];
+        yield 'string unknown' => [FlatColumn::string('s'), ColumnOrder::Unknown, false];
+        yield 'int64 unknown' => [FlatColumn::int64('i'), ColumnOrder::Unknown, false];
+        yield 'int96 type defined' => [FlatColumnMother::int96(), ColumnOrder::TypeDefined, false];
+        yield 'int96 timestamp order' => [FlatColumnMother::int96(), ColumnOrder::Int96Timestamp, false];
+        yield 'interval type defined' => [FlatColumnMother::interval(), ColumnOrder::TypeDefined, false];
+    }
+
+    #[DataProvider('trust')]
+    public function test_is_trusted(FlatColumn $column, ColumnOrder $order, bool $expected): void
+    {
+        static::assertSame($expected, $order->isTrusted($column));
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, ColumnOrder, ?float, ?float, ?float, ?float}>
+     */
+    public static function float_bounds(): Generator
+    {
+        yield 'type defined NaN bounds ignored' => [
+            FlatColumn::double('d'),
+            ColumnOrder::TypeDefined,
+            NAN,
+            NAN,
+            null,
+            null,
+        ];
+        yield 'type defined +0.0 min widened' => [
+            FlatColumn::double('d'),
+            ColumnOrder::TypeDefined,
+            0.0,
+            1.0,
+            -0.0,
+            1.0,
+        ];
+        yield 'type defined -0.0 max widened' => [
+            FlatColumn::float('f'),
+            ColumnOrder::TypeDefined,
+            -1.0,
+            -0.0,
+            -1.0,
+            0.0,
+        ];
+        yield 'type defined plain bounds kept' => [
+            FlatColumn::double('d'),
+            ColumnOrder::TypeDefined,
+            -2.5,
+            3.5,
+            -2.5,
+            3.5,
+        ];
+        yield 'total order zeros kept' => [
+            FlatColumn::double('d'),
+            ColumnOrder::Ieee754TotalOrder,
+            0.0,
+            -0.0,
+            0.0,
+            -0.0,
+        ];
+        yield 'absent untrusted' => [FlatColumn::double('d'), ColumnOrder::Absent, 1.0, 2.0, null, null];
+    }
+
+    #[DataProvider('float_bounds')]
+    public function test_trusted_float_bounds(
+        FlatColumn $column,
+        ColumnOrder $order,
+        ?float $min,
+        ?float $max,
+        ?float $trustedMin,
+        ?float $trustedMax,
+    ): void {
+        static::assertSame(var_export($trustedMin, true), var_export($order->trustedMin($column, $min), true));
+        static::assertSame(var_export($trustedMax, true), var_export($order->trustedMax($column, $max), true));
+    }
+
+    /**
+     * @return Generator<string, array{ColumnOrder, string, string, ?string, ?string}>
+     */
+    public static function float16_bounds(): Generator
+    {
+        yield 'type defined NaN bounds ignored' => [ColumnOrder::TypeDefined, "\x00\x7e", "\x00\x7e", null, null];
+        yield 'type defined +0 min widened' => [
+            ColumnOrder::TypeDefined,
+            "\x00\x00",
+            "\x00\x3c",
+            "\x00\x80",
+            "\x00\x3c",
+        ];
+        yield 'type defined -0 max widened' => [
+            ColumnOrder::TypeDefined,
+            "\x00\xbc",
+            "\x00\x80",
+            "\x00\xbc",
+            "\x00\x00",
+        ];
+        yield 'total order kept' => [ColumnOrder::Ieee754TotalOrder, "\x00\x00", "\x00\x7e", "\x00\x00", "\x00\x7e"];
+    }
+
+    #[DataProvider('float16_bounds')]
+    public function test_trusted_float16_bounds(
+        ColumnOrder $order,
+        string $min,
+        string $max,
+        ?string $trustedMin,
+        ?string $trustedMax,
+    ): void {
+        static::assertSame($trustedMin, $order->trustedMin(FlatColumnMother::float16(), $min));
+        static::assertSame($trustedMax, $order->trustedMax(FlatColumnMother::float16(), $max));
+    }
+
+    public function test_trusted_bounds_of_other_types_are_the_bounds(): void
+    {
+        static::assertSame('a', ColumnOrder::TypeDefined->trustedMin(FlatColumn::string('s'), 'a'));
+        static::assertSame(7, ColumnOrder::TypeDefined->trustedMax(FlatColumn::int64('i'), 7));
+        static::assertNull(ColumnOrder::TypeDefined->trustedMax(FlatColumn::int64('i'), null));
+        static::assertNull(ColumnOrder::Unknown->trustedMin(FlatColumn::int64('i'), 1));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/DecimalConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/DecimalConverterTest.php
index 412daf49b1..1af79242b2 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/DecimalConverterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/DecimalConverterTest.php
@@ -4,6 +4,7 @@
 
 namespace Flow\Parquet\Tests\Unit\ParquetFile\Data\Converter;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Data\Converter\DecimalConverter;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
@@ -15,9 +16,9 @@
 
 final class DecimalConverterTest extends TestCase
 {
-    public function test_for_column_ignores_fixed_len_byte_array_decimals(): void
+    public function test_for_column_ignores_columns_without_decimal(): void
     {
-        static::assertNull(DecimalConverter::forColumn(FlatColumn::decimal('d', 9, 2), Options::default()));
+        static::assertNull(DecimalConverter::forColumn(FlatColumn::int64('i'), Options::default()));
     }
 
     #[TestWith([PhysicalType::INT32])]
@@ -31,6 +32,29 @@ public function test_for_column_on_int_backed_decimals(PhysicalType $type): void
 
         static::assertNotNull($converter);
         static::assertSame(12345.67, $converter->fromParquetType(1234567));
+        static::assertSame(1234567, $converter->toParquetType(12345.67));
+    }
+
+    public function test_for_column_on_fixed_len_byte_array_decimals_uses_the_type_length(): void
+    {
+        $converter = DecimalConverter::forColumn(FlatColumn::decimal('d', 20, 2), Options::default());
+
+        static::assertNotNull($converter);
+        static::assertSame("\x00\x00\x00\x00\x00\x00\x00\x00\x01", $converter->toParquetType(0.01));
+        static::assertSame("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE\xA2", $converter->toParquetType(-3.5));
+        static::assertSame(-3.5, $converter->fromParquetType("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE\xA2"));
+    }
+
+    public function test_for_column_on_byte_array_decimals_uses_minimal_bytes(): void
+    {
+        $converter = DecimalConverter::forColumn(
+            new FlatColumn('d', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::decimal(2, 9)),
+            Options::default(),
+        );
+
+        static::assertNotNull($converter);
+        static::assertSame("\xED\x29\x79", $converter->toParquetType(-12345.67));
+        static::assertSame(-12345.67, $converter->fromParquetType("\xED\x29\x79"));
     }
 
     #[TestWith([2, 1234567, 12345.67])]
@@ -39,20 +63,33 @@ public function test_for_column_on_int_backed_decimals(PhysicalType $type): void
     #[TestWith([2, 123456789012345678, 1234567890123456.8])]
     public function test_from_parquet_type(int $scale, int $value, float $expected): void
     {
-        static::assertSame($expected, (new DecimalConverter(18, $scale))->fromParquetType($value));
+        static::assertSame($expected, (new DecimalConverter(PhysicalType::INT64, 18, $scale))->fromParquetType($value));
     }
 
     #[TestWith([9, 2, 12345.67, 1234567])]
     #[TestWith([9, 2, 0.125, 13])]
     public function test_to_parquet_type(int $precision, int $scale, float $value, int $expected): void
     {
-        static::assertSame($expected, (new DecimalConverter($precision, $scale))->toParquetType($value));
+        static::assertSame(
+            $expected,
+            (new DecimalConverter(PhysicalType::INT32, $precision, $scale))->toParquetType($value),
+        );
     }
 
     public function test_to_parquet_type_over_precision_throws(): void
     {
         $this->expectException(OverflowException::class);
 
-        (new DecimalConverter(9, 2))->toParquetType(12345678.9);
+        (new DecimalConverter(PhysicalType::INT32, 9, 2))->toParquetType(12345678.9);
+    }
+
+    #[TestWith([true])]
+    #[TestWith(['1.25'])]
+    public function test_to_parquet_type_refuses_a_non_number(mixed $value): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Decimal must be written as int or float, got ');
+
+        (new DecimalConverter(PhysicalType::INT64, 10, 2))->toParquetType($value);
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedInt32ConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedInt32ConverterTest.php
new file mode 100644
index 0000000000..6eb2ce1969
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedInt32ConverterTest.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\Data\Converter;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt32Converter;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class UnsignedInt32ConverterTest extends TestCase
+{
+    #[TestWith([-294_967_296, 4_000_000_000])]
+    #[TestWith([-1, 4_294_967_295])]
+    #[TestWith([0, 0])]
+    #[TestWith([2_147_483_647, 2_147_483_647])]
+    public function test_uint32_reads_back_as_itself(int $stored, int $value): void
+    {
+        static::assertSame($value, (new UnsignedInt32Converter())->fromParquetType($stored));
+    }
+
+    public function test_a_value_that_is_not_an_int_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Expected int, got string');
+
+        (new UnsignedInt32Converter())->fromParquetType('1');
+    }
+
+    public function test_writes_are_the_value_itself(): void
+    {
+        static::assertSame(4_000_000_000, (new UnsignedInt32Converter())->toParquetType(4_000_000_000));
+    }
+
+    public function test_for_column_reads_the_converted_type(): void
+    {
+        static::assertEquals(
+            new UnsignedInt32Converter(),
+            UnsignedInt32Converter::forColumn(
+                new FlatColumn('u', PhysicalType::INT32, ConvertedType::UINT_32),
+                Options::default(),
+            ),
+        );
+    }
+
+    public function test_for_column_reads_a_logical_unsigned_integer(): void
+    {
+        static::assertEquals(
+            new UnsignedInt32Converter(),
+            UnsignedInt32Converter::forColumn(
+                new FlatColumn('u', PhysicalType::INT32, logicalType: LogicalType::integer(32, false)),
+                Options::default(),
+            ),
+        );
+    }
+
+    #[TestWith([ConvertedType::UINT_8])]
+    #[TestWith([ConvertedType::UINT_16])]
+    #[TestWith([ConvertedType::UINT_64])]
+    #[TestWith([ConvertedType::INT_32])]
+    #[TestWith([ConvertedType::INT_64])]
+    public function test_for_column_skips_what_it_does_not_convert(ConvertedType $convertedType): void
+    {
+        static::assertNull(UnsignedInt32Converter::forColumn(
+            new FlatColumn('u', PhysicalType::INT32, $convertedType),
+            Options::default(),
+        ));
+        static::assertNull(UnsignedInt32Converter::forColumn(FlatColumn::int64('i'), Options::default()));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedInt64ConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedInt64ConverterTest.php
new file mode 100644
index 0000000000..7d355ef276
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedInt64ConverterTest.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\Data\Converter;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Data\Converter\UnsignedInt64Converter;
+use Flow\Parquet\ParquetFile\Schema\ConvertedType;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use const PHP_INT_MAX;
+use const PHP_INT_MIN;
+
+final class UnsignedInt64ConverterTest extends TestCase
+{
+    #[TestWith([0, '0'])]
+    #[TestWith([PHP_INT_MAX, '9223372036854775807'])]
+    #[TestWith([PHP_INT_MIN, '9223372036854775808'])]
+    #[TestWith([-1, '18446744073709551615'])]
+    public function test_bit_pattern_reads_as_its_decimal_string_and_back(int $physical, string $logical): void
+    {
+        $converter = new UnsignedInt64Converter();
+
+        static::assertSame($logical, $converter->fromParquetType($physical));
+        static::assertSame($physical, $converter->toParquetType($logical));
+    }
+
+    public function test_an_int_writes_as_itself(): void
+    {
+        static::assertSame(PHP_INT_MAX, (new UnsignedInt64Converter())->toParquetType(PHP_INT_MAX));
+    }
+
+    #[TestWith([-1, '-1'])]
+    #[TestWith(['abc', 'abc'])]
+    #[TestWith(['18446744073709551616', '18446744073709551616'])]
+    #[TestWith(['99999999999999999999', '99999999999999999999'])]
+    #[TestWith(['007', '007'])]
+    #[TestWith(['', ''])]
+    #[TestWith([1.5, 'float'])]
+    public function test_a_value_out_of_uint64_is_refused(mixed $value, string $shown): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Expected an int >= 0 or a digit string up to 18446744073709551615, got '
+        . $shown);
+
+        (new UnsignedInt64Converter())->toParquetType($value);
+    }
+
+    public function test_reading_anything_but_an_int_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Expected int, got string');
+
+        (new UnsignedInt64Converter())->fromParquetType('1');
+    }
+
+    public function test_for_column_takes_converted_and_logical_uint64_only(): void
+    {
+        static::assertNotNull(UnsignedInt64Converter::forColumn(
+            new FlatColumn('u', PhysicalType::INT64, ConvertedType::UINT_64),
+            Options::default(),
+        ));
+        static::assertNotNull(UnsignedInt64Converter::forColumn(
+            new FlatColumn('u', PhysicalType::INT64, logicalType: LogicalType::integer(64, false)),
+            Options::default(),
+        ));
+        static::assertNull(UnsignedInt64Converter::forColumn(
+            new FlatColumn('u', PhysicalType::INT32, ConvertedType::UINT_32),
+            Options::default(),
+        ));
+        static::assertNull(UnsignedInt64Converter::forColumn(FlatColumn::int64('i'), Options::default()));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedIntegerConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedIntegerConverterTest.php
deleted file mode 100644
index 2907c4e028..0000000000
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UnsignedIntegerConverterTest.php
+++ /dev/null
@@ -1,91 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Flow\Parquet\Tests\Unit\ParquetFile\Data\Converter;
-
-use Flow\Parquet\Exception\InvalidArgumentException;
-use Flow\Parquet\Exception\RuntimeException;
-use Flow\Parquet\Options;
-use Flow\Parquet\ParquetFile\Data\Converter\UnsignedIntegerConverter;
-use Flow\Parquet\ParquetFile\Schema\ConvertedType;
-use Flow\Parquet\ParquetFile\Schema\FlatColumn;
-use Flow\Parquet\ParquetFile\Schema\LogicalType;
-use Flow\Parquet\ParquetFile\Schema\PhysicalType;
-use PHPUnit\Framework\Attributes\TestWith;
-use PHPUnit\Framework\TestCase;
-
-final class UnsignedIntegerConverterTest extends TestCase
-{
-    #[TestWith([-294_967_296, 4_000_000_000])]
-    #[TestWith([-1, 4_294_967_295])]
-    #[TestWith([0, 0])]
-    #[TestWith([2_147_483_647, 2_147_483_647])]
-    public function test_uint32_reads_back_as_itself(int $stored, int $value): void
-    {
-        static::assertSame($value, (new UnsignedIntegerConverter('u32', 32))->fromParquetType($stored));
-    }
-
-    public function test_uint64_up_to_php_int_max_reads_as_is(): void
-    {
-        static::assertSame(PHP_INT_MAX, (new UnsignedIntegerConverter('u64', 64))->fromParquetType(PHP_INT_MAX));
-    }
-
-    public function test_uint64_above_php_int_max_is_refused(): void
-    {
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Parquet column "u64" holds a UINT_64 value above PHP_INT_MAX');
-
-        (new UnsignedIntegerConverter('u64', 64))->fromParquetType(-1);
-    }
-
-    public function test_a_value_that_is_not_an_int_is_refused(): void
-    {
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Expected int, got string');
-
-        (new UnsignedIntegerConverter('u32', 32))->fromParquetType('1');
-    }
-
-    public function test_writes_are_the_value_itself(): void
-    {
-        static::assertSame(4_000_000_000, (new UnsignedIntegerConverter('u32', 32))->toParquetType(4_000_000_000));
-    }
-
-    #[TestWith([ConvertedType::UINT_32, 32])]
-    #[TestWith([ConvertedType::UINT_64, 64])]
-    public function test_for_column_reads_the_converted_type(ConvertedType $convertedType, int $bitWidth): void
-    {
-        static::assertEquals(
-            new UnsignedIntegerConverter('u', $bitWidth),
-            UnsignedIntegerConverter::forColumn(
-                new FlatColumn('u', PhysicalType::INT64, $convertedType),
-                Options::default(),
-            ),
-        );
-    }
-
-    public function test_for_column_reads_a_logical_unsigned_integer(): void
-    {
-        static::assertEquals(
-            new UnsignedIntegerConverter('u', 32),
-            UnsignedIntegerConverter::forColumn(
-                new FlatColumn('u', PhysicalType::INT32, logicalType: LogicalType::integer(32, false)),
-                Options::default(),
-            ),
-        );
-    }
-
-    #[TestWith([ConvertedType::UINT_8])]
-    #[TestWith([ConvertedType::UINT_16])]
-    #[TestWith([ConvertedType::INT_32])]
-    #[TestWith([ConvertedType::INT_64])]
-    public function test_for_column_skips_what_a_signed_int_holds(ConvertedType $convertedType): void
-    {
-        static::assertNull(UnsignedIntegerConverter::forColumn(
-            new FlatColumn('u', PhysicalType::INT32, $convertedType),
-            Options::default(),
-        ));
-        static::assertNull(UnsignedIntegerConverter::forColumn(FlatColumn::int64('i'), Options::default()));
-    }
-}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UuidConverterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UuidConverterTest.php
index fef13e46d0..ddfc01f82d 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UuidConverterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Data/Converter/UuidConverterTest.php
@@ -4,10 +4,16 @@
 
 namespace Flow\Parquet\Tests\Unit\ParquetFile\Data\Converter;
 
+use Flow\Parquet\Exception\RuntimeException;
 use Flow\Parquet\ParquetFile\Data\Converter\UuidConverter;
+use Flow\Parquet\Tests\Double\StringableUuid;
+use Flow\Parquet\Tests\Double\ToStringUuid;
+use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 use Ramsey\Uuid\Uuid;
 
+use function hex2bin;
+
 final class UuidConverterTest extends TestCase
 {
     public function test_converting_uuid(): void
@@ -18,4 +24,44 @@ public function test_converting_uuid(): void
 
         static::assertEquals($uuid, $converter->fromParquetType($converter->toParquetType($uuid)));
     }
+
+    public function test_physical_value_is_the_16_raw_bytes_whatever_the_case(): void
+    {
+        $converter = new UuidConverter();
+        $bytes = (string) hex2bin('550e8400e29b41d4a716446655440000');
+
+        static::assertSame($bytes, $converter->toParquetType('550E8400-E29B-41D4-A716-446655440000'));
+        static::assertSame($bytes, $converter->toParquetType(new ToStringUuid('550e8400-e29b-41d4-a716-446655440000')));
+        static::assertSame(
+            $bytes,
+            $converter->toParquetType(new StringableUuid('550e8400-e29b-41d4-a716-446655440000')),
+        );
+        static::assertSame('550e8400-e29b-41d4-a716-446655440000', $converter->fromParquetType($bytes));
+    }
+
+    #[TestWith(['550e8400-e29b-41d4-a716-44665544000'])]
+    #[TestWith(['zz0e8400-e29b-41d4-a716-446655440000'])]
+    public function test_malformed_uuid_is_refused(string $uuid): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Invalid UUID format: ' . $uuid);
+
+        (new UuidConverter())->toParquetType($uuid);
+    }
+
+    public function test_reading_anything_but_16_bytes_is_refused(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('UUID must be read as 16 bytes from Parquet file');
+
+        (new UuidConverter())->fromParquetType('550e8400-e29b-41d4-a716-446655440000');
+    }
+
+    public function test_writing_a_non_uuid_value_is_refused(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('UUID must be written as a string or Stringable object');
+
+        (new UuidConverter())->toParquetType(1);
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Index/IndexLocationTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Index/IndexLocationTest.php
new file mode 100644
index 0000000000..1c06305b93
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Index/IndexLocationTest.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\Index;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Index\IndexLocation;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class IndexLocationTest extends TestCase
+{
+    #[TestWith([-1, 10])]
+    #[TestWith([0, 0])]
+    public function test_a_location_before_the_file_or_of_no_bytes_is_refused(int $offset, int $length): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'An index location needs an offset of at least 0 and a length of at least 1, got '
+            . $offset
+            . ' and '
+            . $length,
+        );
+
+        new IndexLocation($offset, $length);
+    }
+
+    #[TestWith([null, 10])]
+    #[TestWith([10, null])]
+    #[TestWith([-1, 10])]
+    #[TestWith([10, 0])]
+    public function test_an_absent_or_unreadable_thrift_location_is_none(?int $offset, ?int $length): void
+    {
+        static::assertNull(IndexLocation::fromThrift($offset, $length));
+    }
+
+    public function test_a_thrift_location_is_read_as_ints(): void
+    {
+        static::assertEquals(new IndexLocation(4, 20), IndexLocation::fromThrift(4, 20));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Index/StreamIndexesTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Index/StreamIndexesTest.php
new file mode 100644
index 0000000000..19ae4ff5fb
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Index/StreamIndexesTest.php
@@ -0,0 +1,201 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\Index;
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\ParquetFile\Index\IndexLocation;
+use Flow\Parquet\ParquetFile\Index\StreamIndexes;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
+use Flow\Parquet\ParquetFile\RowGroup;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Context\ThriftBytes;
+use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
+use Flow\Parquet\Tests\Double\SpyFooter;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use Flow\Parquet\Tests\Mother\SbbfMother;
+use Flow\Parquet\ThriftModel\BloomFilterAlgorithm;
+use Flow\Parquet\ThriftModel\BloomFilterCompression;
+use Flow\Parquet\ThriftModel\BloomFilterHash;
+use Flow\Parquet\ThriftModel\BloomFilterHeader;
+use Flow\Parquet\ThriftModel\ColumnIndex as ThriftColumnIndex;
+use Flow\Parquet\ThriftModel\OffsetIndex as ThriftOffsetIndex;
+use Flow\Parquet\ThriftModel\SplitBlockAlgorithm;
+use Flow\Parquet\ThriftModel\Uncompressed;
+use Flow\Parquet\ThriftModel\XxHash;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+use function strlen;
+
+final class StreamIndexesTest extends TestCase
+{
+    public function test_an_index_is_read_from_its_offset_once_and_only_for_the_column_asked(): void
+    {
+        $id = FlatColumn::int64('id');
+        $name = FlatColumn::string('name');
+        $columnIndex = new ColumnIndex([false], [pack('P', 1)], [pack('P', 9)], BoundaryOrder::ASCENDING, [0]);
+        $offsetIndex = new OffsetIndex([new PageLocation(4, 20, 0)]);
+        $columnBytes = ThriftBytes::of($columnIndex->toThrift());
+        $offsetBytes = ThriftBytes::of($offsetIndex->toThrift());
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1' . $columnBytes . $offsetBytes));
+        $footer = new SpyFooter(Schema::with($id, $name), 2, [new RowGroup([
+            ColumnChunkMother::withIndexes(
+                $id,
+                new IndexLocation(4, strlen($columnBytes)),
+                new IndexLocation(4 + strlen($columnBytes), strlen($offsetBytes)),
+            ),
+            ColumnChunkMother::withStatistics($name, null),
+        ], 2)]);
+        $indexes = new StreamIndexes($footer, $stream);
+
+        static::assertEquals($columnIndex, $indexes->columnIndex(0, $id));
+        static::assertEquals($columnIndex, $indexes->columnIndex(0, $id));
+        static::assertEquals($offsetIndex, $indexes->offsetIndex(0, $id));
+        static::assertEquals($offsetIndex, $indexes->offsetIndex(0, $id));
+        static::assertSame(2, $stream->reads);
+        static::assertSame(strlen($columnBytes) + strlen($offsetBytes), $stream->bytes);
+        static::assertEquals([[$id]], $footer->rowGroupChunkReads);
+    }
+
+    public function test_a_bloom_filter_is_read_once(): void
+    {
+        $id = FlatColumn::int64('id');
+        $sbbf = SbbfMother::with($id, 3);
+        $bytes = $sbbf->serialized();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1' . $bytes));
+        $indexes = new StreamIndexes(new SpyFooter(Schema::with($id), 2, [new RowGroup(
+            [ColumnChunkMother::withBloomFilter($id, 4, strlen($bytes))],
+            2,
+        )]), $stream);
+
+        static::assertEquals($sbbf, $indexes->bloomFilter(0, $id));
+        static::assertEquals($sbbf, $indexes->bloomFilter(0, $id));
+        static::assertSame(1, $stream->reads);
+    }
+
+    /**
+     * @return iterable<string, array{string}>
+     */
+    public static function malformed_bloom_filters(): iterable
+    {
+        yield 'not thrift' => ["\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"];
+        yield 'no bytes declared' => [ThriftBytes::of(new BloomFilterHeader([
+            'numBytes' => 0,
+            'algorithm' => new BloomFilterAlgorithm(['BLOCK' => new SplitBlockAlgorithm()]),
+            'hash' => new BloomFilterHash(['XXHASH' => new XxHash()]),
+            'compression' => new BloomFilterCompression(['UNCOMPRESSED' => new Uncompressed()]),
+        ]))];
+        yield 'fewer bytes than declared' => [
+            ThriftBytes::of(new BloomFilterHeader([
+                'numBytes' => 32,
+                'algorithm' => new BloomFilterAlgorithm(['BLOCK' => new SplitBlockAlgorithm()]),
+                'hash' => new BloomFilterHash(['XXHASH' => new XxHash()]),
+                'compression' => new BloomFilterCompression(['UNCOMPRESSED' => new Uncompressed()]),
+            ])) . 'short',
+        ];
+    }
+
+    #[DataProvider('malformed_bloom_filters')]
+    public function test_a_bloom_filter_that_fails_to_decode_is_none(string $bytes): void
+    {
+        $id = FlatColumn::int64('id');
+
+        static::assertNull((new StreamIndexes(new SpyFooter(Schema::with($id), 2, [new RowGroup(
+            [ColumnChunkMother::withBloomFilter($id, 4, strlen($bytes))],
+            2,
+        )]), new MemorySourceStream('PAR1' . $bytes)))->bloomFilter(0, $id));
+    }
+
+    public function test_a_chunk_without_indexes_reads_nothing(): void
+    {
+        $name = FlatColumn::string('name');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream('PAR1'));
+        $indexes = new StreamIndexes(new SpyFooter(Schema::with($name), 2, [new RowGroup(
+            [ColumnChunkMother::withStatistics($name, null)],
+            2,
+        )]), $stream);
+
+        static::assertNull($indexes->columnIndex(0, $name));
+        static::assertNull($indexes->offsetIndex(0, $name));
+        static::assertNull($indexes->bloomFilter(0, $name));
+        static::assertSame(0, $stream->reads);
+    }
+
+    /**
+     * @return iterable<string, array{string}>
+     */
+    public static function malformed_column_indexes(): iterable
+    {
+        yield 'not thrift' => ["\xFF\xFF\xFF\xFF"];
+        yield 'unknown boundary order' => [ThriftBytes::of(new ThriftColumnIndex([
+            'null_pages' => [false],
+            'min_values' => ['a'],
+            'max_values' => ['b'],
+            'boundary_order' => 7,
+        ]))];
+        yield 'no null pages' => [ThriftBytes::of(new ThriftColumnIndex([
+            'min_values' => ['a'],
+            'max_values' => ['b'],
+            'boundary_order' => 0,
+        ]))];
+        yield 'lists of other lengths' => [ThriftBytes::of(new ThriftColumnIndex([
+            'null_pages' => [false, false],
+            'min_values' => ['a'],
+            'max_values' => ['b'],
+            'boundary_order' => 0,
+        ]))];
+    }
+
+    #[DataProvider('malformed_column_indexes')]
+    public function test_a_column_index_that_fails_to_decode_is_none(string $bytes): void
+    {
+        $id = FlatColumn::int64('id');
+
+        static::assertNull((new StreamIndexes(new SpyFooter(Schema::with($id), 2, [new RowGroup([
+            ColumnChunkMother::withIndexes($id, new IndexLocation(4, strlen($bytes)), null),
+        ], 2)]), new MemorySourceStream('PAR1' . $bytes)))->columnIndex(0, $id));
+    }
+
+    /**
+     * @return iterable<string, array{string}>
+     */
+    public static function malformed_offset_indexes(): iterable
+    {
+        yield 'not thrift' => ["\xFF\xFF\xFF\xFF"];
+        yield 'no pages' => [ThriftBytes::of(new ThriftOffsetIndex(['page_locations' => []]))];
+        yield 'no page locations' => [ThriftBytes::of(new ThriftOffsetIndex([]))];
+        yield 'a page outside the chunk' => [ThriftBytes::of(
+            (new OffsetIndex([new PageLocation(20, 10, 0)]))->toThrift(),
+        )];
+        yield 'an empty page' => [ThriftBytes::of((new OffsetIndex([new PageLocation(4, 0, 0)]))->toThrift())];
+        yield 'pages out of order' => [ThriftBytes::of(
+            (new OffsetIndex([
+                new PageLocation(14, 10, 0),
+                new PageLocation(4, 10, 1),
+            ]))->toThrift(),
+        )];
+        yield 'rows past the row group' => [ThriftBytes::of(
+            (new OffsetIndex([
+                new PageLocation(4, 10, 0),
+                new PageLocation(14, 10, 2),
+            ]))->toThrift(),
+        )];
+    }
+
+    #[DataProvider('malformed_offset_indexes')]
+    public function test_an_offset_index_that_fails_to_decode_or_does_not_fit_its_chunk_is_none(string $bytes): void
+    {
+        $id = FlatColumn::int64('id');
+
+        static::assertNull((new StreamIndexes(new SpyFooter(Schema::with($id), 2, [new RowGroup([
+            ColumnChunkMother::withIndexes($id, null, new IndexLocation(4, strlen($bytes))),
+        ], 2)]), new MemorySourceStream('PAR1' . $bytes)))->offsetIndex(0, $id));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/MetadataRowGroupChunksTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/MetadataRowGroupChunksTest.php
new file mode 100644
index 0000000000..347cb63c75
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/MetadataRowGroupChunksTest.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile;
+
+use Flow\Parquet\Exception\OutOfBoundsException;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use PHPUnit\Framework\TestCase;
+
+final class MetadataRowGroupChunksTest extends TestCase
+{
+    public function test_the_chunks_and_orders_are_the_footer_ones(): void
+    {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata();
+        $id = $metadata->schema()->getFlat('id');
+        $chunks = new MetadataRowGroupChunks($metadata);
+
+        static::assertSame([2, 2, 2], $chunks->rowCounts());
+        static::assertEquals($metadata->rowGroups()->all()[2]->getColumnChunk($id), $chunks->chunk(2, $id));
+        static::assertSame($metadata->columnOrder($id), $chunks->columnOrder($id));
+    }
+
+    public function test_a_row_group_the_file_lacks_is_refused(): void
+    {
+        $metadata = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::threeRowGroups())->metadata();
+
+        $this->expectException(OutOfBoundsException::class);
+        $this->expectExceptionMessage('Row group 3 does not exist');
+
+        (new MetadataRowGroupChunks($metadata))->chunk(3, $metadata->schema()->getFlat('id'));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/MetadataTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/MetadataTest.php
new file mode 100644
index 0000000000..451ee8217f
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/MetadataTest.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\ColumnOrder;
+use Flow\Parquet\ParquetFile\Metadata;
+use Flow\Parquet\ParquetFile\RowGroups;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use PHPUnit\Framework\TestCase;
+
+final class MetadataTest extends TestCase
+{
+    public function test_column_orders_round_trip_per_leaf(): void
+    {
+        $schema = Schema::with(
+            FlatColumn::string('name'),
+            NestedColumn::struct('point', [FlatColumn::double('x'), FlatColumn::int64('y')]),
+        );
+        $read = Metadata::fromThrift(
+            (new Metadata(
+                $schema,
+                new RowGroups([]),
+                0,
+                1,
+                null,
+                [
+                    ColumnOrder::TypeDefined,
+                    ColumnOrder::Ieee754TotalOrder,
+                    ColumnOrder::TypeDefined,
+                ],
+            ))->toThrift(),
+        );
+
+        static::assertSame(ColumnOrder::TypeDefined, $read->columnOrder($schema->getFlat('name')));
+        static::assertSame(ColumnOrder::Ieee754TotalOrder, $read->columnOrder($schema->getFlat('point.x')));
+        static::assertSame(ColumnOrder::TypeDefined, $read->columnOrder($schema->getFlat('point.y')));
+    }
+
+    public function test_footer_without_column_orders_is_absent(): void
+    {
+        $schema = Schema::with(FlatColumn::string('name'));
+        static::assertSame(
+            ColumnOrder::Absent,
+            Metadata::fromThrift(
+                (new Metadata($schema, new RowGroups([]), 0, 1, null))->toThrift(),
+            )->columnOrder($schema->getFlat('name')),
+        );
+    }
+
+    public function test_footer_with_fewer_column_orders_than_leaves_is_refused(): void
+    {
+        $schema = Schema::with(FlatColumn::string('a'), FlatColumn::string('b'));
+        $thrift = (new Metadata($schema, new RowGroups([]), 0, 1, null))->toThrift();
+        $thrift->column_orders = [ColumnOrder::TypeDefined->toThrift()];
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Footer holds 1 column orders for 2 leaf columns');
+
+        Metadata::fromThrift($thrift);
+    }
+
+    public function test_column_order_of_a_column_outside_the_schema_is_refused(): void
+    {
+        $metadata = new Metadata(
+            Schema::with(FlatColumn::string('a')),
+            new RowGroups([]),
+            0,
+            1,
+            null,
+            [
+                ColumnOrder::TypeDefined,
+            ],
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "b" is not a leaf of the schema');
+
+        $metadata->columnOrder(FlatColumn::string('b'));
+    }
+
+    public function test_an_unknown_column_order_is_written_back_as_unknown(): void
+    {
+        $schema = Schema::with(FlatColumn::string('a'), FlatColumn::double('b'));
+        $read = Metadata::fromThrift(
+            (new Metadata(
+                $schema,
+                new RowGroups([]),
+                0,
+                1,
+                null,
+                [
+                    ColumnOrder::Unknown,
+                    ColumnOrder::Ieee754TotalOrder,
+                ],
+            ))->toThrift(),
+        );
+
+        static::assertSame(ColumnOrder::Unknown, $read->columnOrder($schema->getFlat('a')));
+        static::assertSame(ColumnOrder::Ieee754TotalOrder, $read->columnOrder($schema->getFlat('b')));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Page/Header/DataPageHeaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Page/Header/DataPageHeaderTest.php
new file mode 100644
index 0000000000..b3584fd42e
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Page/Header/DataPageHeaderTest.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\Page\Header;
+
+use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\Page\Header\DataPageHeader;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Statistics;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+
+final class DataPageHeaderTest extends TestCase
+{
+    public function test_page_statistics_are_kept_through_thrift(): void
+    {
+        $header = DataPageHeader::fromThrift(
+            (new DataPageHeader(
+                Encodings::PLAIN,
+                Encodings::RLE,
+                Encodings::RLE,
+                2,
+                new Statistics(null, null, 1, null, pack('P', 9), pack('P', 1)),
+            ))->toThrift(),
+        );
+
+        static::assertSame(1, $header->statistics()?->minValue(FlatColumn::int64('id')));
+        static::assertSame(9, $header->statistics()?->maxValue(FlatColumn::int64('id')));
+        static::assertSame(1, $header->statistics()?->nullCount());
+    }
+
+    public function test_a_page_without_statistics_has_none(): void
+    {
+        static::assertNull(
+            DataPageHeader::fromThrift(
+                (new DataPageHeader(Encodings::PLAIN, Encodings::RLE, Encodings::RLE, 2))->toThrift(),
+            )->statistics(),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Page/PageHeaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Page/PageHeaderTest.php
new file mode 100644
index 0000000000..406137620f
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Page/PageHeaderTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\Page;
+
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Page\PageHeader;
+use Flow\Parquet\Tests\Context\ThriftBytes;
+use Flow\Parquet\ThriftModel\DataPageHeader;
+use Flow\Parquet\ThriftModel\PageHeader as ThriftPageHeader;
+use PHPUnit\Framework\TestCase;
+
+use function fopen;
+use function ftell;
+use function fwrite;
+use function rewind;
+use function strlen;
+
+final class PageHeaderTest extends TestCase
+{
+    public function test_a_header_is_read_and_the_stream_left_after_it(): void
+    {
+        $bytes = ThriftBytes::of(new ThriftPageHeader([
+            'type' => 0,
+            'uncompressed_page_size' => 10,
+            'compressed_page_size' => 8,
+            'data_page_header' => new DataPageHeader([
+                'num_values' => 2,
+                'encoding' => 0,
+                'definition_level_encoding' => 3,
+                'repetition_level_encoding' => 3,
+            ]),
+        ]));
+        $stream = fopen('php://memory', 'rb+') ?: static::fail('No memory stream');
+        fwrite($stream, $bytes . 'page');
+        rewind($stream);
+
+        static::assertSame(8, PageHeader::read($stream, new Options())?->compressedPageSize());
+        static::assertSame(strlen($bytes), ftell($stream));
+    }
+
+    public function test_no_header_is_null_and_keeps_the_position(): void
+    {
+        $stream = fopen('php://memory', 'rb+') ?: static::fail('No memory stream');
+        fwrite($stream, "\xFF\xFF\xFF\xFF");
+        rewind($stream);
+
+        static::assertNull(PageHeader::read($stream, new Options()));
+        static::assertSame(0, ftell($stream));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/ColumnIndexTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/ColumnIndexTest.php
new file mode 100644
index 0000000000..8b88026bf7
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/ColumnIndexTest.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\PageIndex;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use PHPUnit\Framework\TestCase;
+
+final class ColumnIndexTest extends TestCase
+{
+    public function test_it_round_trips_through_thrift_with_null_and_nan_counts(): void
+    {
+        $index = new ColumnIndex([false, true], ['a', ''], ['c', ''], BoundaryOrder::ASCENDING, [0, 3], [1, 0]);
+
+        static::assertEquals($index, ColumnIndex::fromThrift($index->toThrift()));
+        static::assertSame(2, $index->pages());
+    }
+
+    public function test_counts_a_writer_left_out_stay_unknown(): void
+    {
+        $index = new ColumnIndex([false], ['a'], ['c'], BoundaryOrder::UNORDERED);
+
+        static::assertEquals($index, ColumnIndex::fromThrift($index->toThrift()));
+        static::assertNull(ColumnIndex::fromThrift($index->toThrift())->nullCounts);
+    }
+
+    public function test_lists_of_another_length_than_the_pages_are_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Every list of a column index has one entry per page');
+
+        new ColumnIndex([false, false], ['a', 'b'], ['c', 'd'], BoundaryOrder::UNORDERED, null, [0]);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/OffsetIndexTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/OffsetIndexTest.php
new file mode 100644
index 0000000000..ce5b31b04c
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/OffsetIndexTest.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\PageIndex;
+
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use Flow\Parquet\Tests\Mother\PageIndexMother;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+final class OffsetIndexTest extends TestCase
+{
+    public function test_it_round_trips_through_thrift(): void
+    {
+        $index = new OffsetIndex([new PageLocation(4, 30, 0), new PageLocation(34, 25, 7)]);
+
+        static::assertEquals($index, OffsetIndex::fromThrift($index->toThrift()));
+    }
+
+    #[TestWith([0, 0])]
+    #[TestWith([3, 0])]
+    #[TestWith([4, 1])]
+    #[TestWith([6, 1])]
+    #[TestWith([7, 2])]
+    #[TestWith([20, 2])]
+    public function test_the_page_of_a_row_is_the_last_page_starting_at_or_before_it(int $row, int $page): void
+    {
+        static::assertSame($page, PageIndexMother::pagesAt(0, 4, 7)->pageOf($row));
+    }
+
+    public function test_a_page_ends_where_the_next_begins_and_the_last_at_the_row_group_end(): void
+    {
+        $index = PageIndexMother::pagesAt(0, 4, 7);
+
+        static::assertSame([4, 3, 3], [$index->pageRows(0, 10), $index->pageRows(1, 10), $index->pageRows(2, 10)]);
+    }
+
+    /**
+     * @param list<int> $firstRows
+     */
+    #[TestWith([[0, 4, 7], true])]
+    #[TestWith([[0], true])]
+    #[TestWith([[], false])]
+    #[TestWith([[1, 4], false])]
+    #[TestWith([[0, 5, 3], false])]
+    #[TestWith([[0, 4, 4], false])]
+    #[TestWith([[0, 10], false])]
+    public function test_pages_fit_a_row_group_when_they_start_at_row_zero_and_increase_inside_it(
+        array $firstRows,
+        bool $fits,
+    ): void {
+        static::assertSame($fits, PageIndexMother::pagesAt(...$firstRows)->fits(
+            ColumnChunkMother::spanning(FlatColumn::int64('id'), 100, 30),
+            10,
+        ));
+    }
+
+    /**
+     * @param list<array{int, int}> $pages offset and size of pages starting at rows 0, 5, ...
+     */
+    #[TestWith([[[100, 10], [110, 20]], true])]
+    #[TestWith([[[99, 10], [110, 10]], false])]
+    #[TestWith([[[100, 10], [125, 10]], false])]
+    #[TestWith([[[100, 0], [110, 10]], false])]
+    #[TestWith([[[110, 10], [100, 10]], false])]
+    #[TestWith([[[100, 15], [110, 10]], false])]
+    public function test_pages_fit_a_chunk_when_they_lie_inside_it_one_after_another(array $pages, bool $fits): void
+    {
+        $locations = [];
+
+        foreach ($pages as $page => [$offset, $size]) {
+            $locations[] = new PageLocation($offset, $size, $page * 5);
+        }
+
+        static::assertSame($fits, (new OffsetIndex($locations))->fits(
+            ColumnChunkMother::spanning(FlatColumn::int64('id'), 100, 30),
+            10,
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/PageIndexTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/PageIndexTest.php
new file mode 100644
index 0000000000..2a451b4244
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/PageIndex/PageIndexTest.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\PageIndex;
+
+use Flow\Parquet\ParquetFile\PageIndex\PageIndex;
+use Flow\Parquet\Tests\Mother\PageIndexMother;
+use PHPUnit\Framework\TestCase;
+
+final class PageIndexTest extends TestCase
+{
+    public function test_a_column_index_and_offset_index_that_agree_are_a_page_index(): void
+    {
+        $pageIndex = PageIndex::of(PageIndexMother::int64([[0, 3], [4, 9]]), PageIndexMother::pagesAt(0, 4), 10);
+
+        static::assertSame([1, 6], [$pageIndex?->pageOf(5), $pageIndex?->pageRows(1)]);
+    }
+
+    public function test_a_missing_index_is_no_page_index(): void
+    {
+        static::assertNull(PageIndex::of(null, PageIndexMother::pagesAt(0), 10));
+        static::assertNull(PageIndex::of(PageIndexMother::int64([[0, 9]]), null, 10));
+    }
+
+    public function test_indexes_of_different_page_counts_are_no_page_index(): void
+    {
+        static::assertNull(PageIndex::of(PageIndexMother::int64([[0, 9]]), PageIndexMother::pagesAt(0, 5), 10));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/RowGroup/ColumnChunkTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/RowGroup/ColumnChunkTest.php
new file mode 100644
index 0000000000..d5d0581fd5
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/RowGroup/ColumnChunkTest.php
@@ -0,0 +1,149 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\RowGroup;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\ParquetFile\Index\IndexLocation;
+use Flow\Parquet\ParquetFile\RowGroup\ColumnChunk;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use Flow\Parquet\ThriftModel\ColumnChunk as ThriftColumnChunk;
+use Flow\Parquet\ThriftModel\ColumnMetaData;
+use PHPUnit\Framework\TestCase;
+
+final class ColumnChunkTest extends TestCase
+{
+    public function test_a_column_chunk_without_metadata_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Column chunk at offset 4 has no metadata (an encrypted column is not supported)',
+        );
+
+        ColumnChunk::fromThrift(new ThriftColumnChunk(['file_offset' => 4]));
+    }
+
+    public function test_page_index_locations_round_trip_through_thrift(): void
+    {
+        $chunk = new ColumnChunk(
+            PhysicalType::INT64,
+            Compressions::UNCOMPRESSED,
+            2,
+            4,
+            ['id'],
+            [],
+            10,
+            10,
+            null,
+            4,
+            null,
+            null,
+            new IndexLocation(100, 20),
+            new IndexLocation(120, 15),
+        );
+
+        static::assertEquals($chunk, ColumnChunk::fromThrift($chunk->toThrift()));
+        static::assertEquals(new IndexLocation(100, 20), $chunk->columnIndex());
+        static::assertEquals(new IndexLocation(120, 15), $chunk->offsetIndex());
+    }
+
+    public function test_a_bloom_filter_location_round_trips_through_thrift_and_survives_page_index_locations(): void
+    {
+        $chunk = ColumnChunkMother::withBloomFilter(FlatColumn::int64('id'), 200, 48);
+
+        static::assertEquals($chunk, ColumnChunk::fromThrift($chunk->toThrift()));
+        static::assertSame(200, $chunk->bloomFilterOffset());
+        static::assertSame(48, $chunk->bloomFilterLength());
+
+        $indexed = $chunk->withLocations(offsetIndex: new IndexLocation(120, 15));
+
+        static::assertSame(200, $indexed->bloomFilterOffset());
+        static::assertSame(48, $indexed->bloomFilterLength());
+        static::assertEquals(new IndexLocation(120, 15), $indexed->offsetIndex());
+    }
+
+    public function test_a_chunk_records_the_bloom_filter_written_for_it(): void
+    {
+        $chunk = ColumnChunkMother::withIndexes(
+            FlatColumn::int64('id'),
+            null,
+            new IndexLocation(120, 15),
+        )->withLocations(bloomFilterOffset: 300, bloomFilterLength: 64);
+
+        static::assertSame(300, $chunk->bloomFilterOffset());
+        static::assertSame(64, $chunk->bloomFilterLength());
+        static::assertEquals(new IndexLocation(120, 15), $chunk->offsetIndex());
+    }
+
+    public function test_a_location_no_index_can_be_read_from_is_no_location(): void
+    {
+        $thrift = (new ColumnChunk(
+            PhysicalType::INT64,
+            Compressions::UNCOMPRESSED,
+            2,
+            4,
+            ['id'],
+            [],
+            10,
+            10,
+            null,
+            4,
+            null,
+            null,
+        ))->toThrift();
+        $thrift->column_index_offset = 100;
+        $thrift->column_index_length = 0;
+        $thrift->offset_index_offset = -1;
+        $thrift->offset_index_length = 15;
+
+        static::assertNull(ColumnChunk::fromThrift($thrift)->columnIndex());
+        static::assertNull(ColumnChunk::fromThrift($thrift)->offsetIndex());
+    }
+
+    public function test_a_bloom_filter_length_without_its_offset_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A column chunk records a bloom filter length without its offset');
+
+        new ColumnChunk(
+            PhysicalType::INT64,
+            Compressions::UNCOMPRESSED,
+            2,
+            4,
+            ['id'],
+            [],
+            10,
+            10,
+            null,
+            4,
+            null,
+            null,
+            bloomFilterLength: 48,
+        );
+    }
+
+    public function test_a_bloom_filter_length_read_without_its_offset_is_dropped(): void
+    {
+        $chunk = ColumnChunk::fromThrift(new ThriftColumnChunk([
+            'file_offset' => 4,
+            'meta_data' => new ColumnMetaData([
+                'type' => 2,
+                'encodings' => [],
+                'path_in_schema' => ['id'],
+                'codec' => 0,
+                'num_values' => 2,
+                'total_uncompressed_size' => 0,
+                'total_compressed_size' => 0,
+                'data_page_offset' => 4,
+                'bloom_filter_length' => 48,
+            ]),
+        ]));
+
+        static::assertNull($chunk->bloomFilterOffset());
+        static::assertNull($chunk->bloomFilterLength());
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/RowGroup/StatisticsReaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/RowGroup/StatisticsReaderTest.php
new file mode 100644
index 0000000000..d30e392a88
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/RowGroup/StatisticsReaderTest.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\ParquetFile\RowGroup;
+
+use Flow\Parquet\ParquetFile\RowGroup\StatisticsReader;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\ParquetFile\Statistics;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+
+final class StatisticsReaderTest extends TestCase
+{
+    public function test_binary_statistics_decode_without_a_length_prefix(): void
+    {
+        $reader = new StatisticsReader(new Statistics("\x00\xff", "\x00\x01", 0, null, "\x00\xff", "\x00\x01"));
+        $column = new FlatColumn('b', PhysicalType::BYTE_ARRAY);
+
+        static::assertSame("\x00\x01", $reader->minValue($column));
+        static::assertSame("\x00\xff", $reader->maxValue($column));
+        static::assertSame("\x00\x01", $reader->min($column));
+        static::assertSame("\x00\xff", $reader->max($column));
+    }
+
+    public function test_byte_array_decimal_statistics_decode_to_unscaled_bytes(): void
+    {
+        $reader = new StatisticsReader(new Statistics(null, null, 0, null, "\x12\xD6\x87", "\xED\x29\x79"));
+
+        static::assertSame("\xED\x29\x79", $reader->minValue(FlatColumnMother::byteArrayDecimal()));
+        static::assertSame("\x12\xD6\x87", $reader->maxValue(FlatColumnMother::byteArrayDecimal()));
+    }
+
+    public function test_int64_decimal_statistics_decode_to_the_unscaled_int(): void
+    {
+        $reader = new StatisticsReader(new Statistics(null, null, 0, null, null, pack('P', -350)));
+
+        static::assertSame(-350, $reader->minValue(FlatColumn::decimal('d', 10, 2)));
+        static::assertNull($reader->maxValue(FlatColumn::decimal('d', 10, 2)));
+    }
+
+    public function test_counts_and_exactness_are_exposed(): void
+    {
+        $reader = new StatisticsReader(new Statistics(null, null, 3, 7, null, null, false, true, 2));
+
+        static::assertSame(3, $reader->nullCount());
+        static::assertSame(7, $reader->distinctCount());
+        static::assertSame(2, $reader->nanCount());
+        static::assertFalse($reader->isMaxValueExact());
+        static::assertTrue($reader->isMinValueExact());
+        static::assertNull($reader->min(FlatColumn::int64('i')));
+        static::assertNull($reader->max(FlatColumn::int64('i')));
+    }
+
+    public function test_a_statistic_of_the_wrong_width_reads_as_absent(): void
+    {
+        $doubled = pack('P', 99) . pack('P', 99);
+        $reader = new StatisticsReader(new Statistics($doubled, $doubled, 0, null, $doubled, "\x01"));
+
+        static::assertNull($reader->min(FlatColumn::int64('i')));
+        static::assertNull($reader->max(FlatColumn::int64('i')));
+        static::assertNull($reader->maxValue(FlatColumn::int64('i')));
+        static::assertNull($reader->minValue(FlatColumn::int32('i')));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/FlatColumnTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/FlatColumnTest.php
index fdd6851eb0..20da6a1723 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/FlatColumnTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/FlatColumnTest.php
@@ -9,6 +9,8 @@
 use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Time;
+use Flow\Parquet\ParquetFile\Schema\LogicalType\Timestamp;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\ParquetFile\Schema\Repetition;
 use Flow\Parquet\ParquetFile\Schema\TimeUnit;
@@ -17,17 +19,13 @@
 use Flow\Parquet\ThriftModel\SchemaElement;
 use Flow\Parquet\ThriftModel\TimestampType;
 use Flow\Parquet\ThriftModel\TimeUnit as ThriftTimeUnit;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
 final class FlatColumnTest extends TestCase
 {
-    #[TestWith([1, 1])]
-    #[TestWith([6, 3])]
-    #[TestWith([7, 4])]
-    #[TestWith([11, 5])]
-    #[TestWith([12, 6])]
-    #[TestWith([18, 8])]
     #[TestWith([19, 9])]
     #[TestWith([23, 10])]
     #[TestWith([24, 11])]
@@ -36,7 +34,24 @@ final class FlatColumnTest extends TestCase
     #[TestWith([38, 16])]
     public function test_decimal_byte_length_follows_the_spec(int $precision, int $length): void
     {
-        static::assertSame($length, FlatColumn::decimal('d', $precision, 0)->typeLength());
+        $column = FlatColumn::decimal('d', $precision, 0);
+
+        static::assertSame(PhysicalType::FIXED_LEN_BYTE_ARRAY, $column->type());
+        static::assertSame($length, $column->typeLength());
+    }
+
+    #[TestWith([1, PhysicalType::INT32])]
+    #[TestWith([9, PhysicalType::INT32])]
+    #[TestWith([10, PhysicalType::INT64])]
+    #[TestWith([18, PhysicalType::INT64])]
+    public function test_decimal_physical_type_follows_precision(int $precision, PhysicalType $type): void
+    {
+        $column = FlatColumn::decimal('d', $precision, 2);
+
+        static::assertSame($type, $column->type());
+        static::assertNull($column->typeLength());
+        static::assertSame($precision, $column->logicalType()?->decimalData()?->precision());
+        static::assertSame(2, $column->logicalType()?->decimalData()?->scale());
     }
 
     #[TestWith([0])]
@@ -116,6 +131,117 @@ public function test_enum_is_annotated_enum(): void
 
         static::assertSame(ConvertedType::ENUM, $column->convertedType());
         static::assertSame(LogicalType::ENUM, $column->logicalType()?->name());
-        static::assertNotNull($column->toThrift()->logicalType->ENUM);
+        static::assertNotNull($column->toThrift()->logicalType?->ENUM);
+    }
+
+    /**
+     * @return Generator<string, array{LogicalType, ConvertedType}>
+     */
+    public static function agreeing_annotations(): Generator
+    {
+        yield 'string' => [LogicalType::string(), ConvertedType::UTF8];
+        yield 'enum' => [LogicalType::enum(), ConvertedType::ENUM];
+        yield 'json' => [LogicalType::json(), ConvertedType::JSON];
+        yield 'bson' => [LogicalType::bson(), ConvertedType::BSON];
+        yield 'decimal' => [LogicalType::decimal(2, 10), ConvertedType::DECIMAL];
+        yield 'date' => [LogicalType::date(), ConvertedType::DATE];
+        yield 'time millis' => [
+            new LogicalType(LogicalType::TIME, time: new Time(true, TimeUnit::MILLISECONDS)),
+            ConvertedType::TIME_MILLIS,
+        ];
+        yield 'time micros' => [LogicalType::time(), ConvertedType::TIME_MICROS];
+        yield 'timestamp millis' => [
+            new LogicalType(LogicalType::TIMESTAMP, timestamp: new Timestamp(true, TimeUnit::MILLISECONDS)),
+            ConvertedType::TIMESTAMP_MILLIS,
+        ];
+        yield 'timestamp micros' => [LogicalType::timestamp(), ConvertedType::TIMESTAMP_MICROS];
+        yield 'int8' => [LogicalType::integer(8, true), ConvertedType::INT_8];
+        yield 'int16' => [LogicalType::integer(16, true), ConvertedType::INT_16];
+        yield 'int32' => [LogicalType::integer(32, true), ConvertedType::INT_32];
+        yield 'int64' => [LogicalType::integer(64, true), ConvertedType::INT_64];
+        yield 'uint8' => [LogicalType::integer(8, false), ConvertedType::UINT_8];
+        yield 'uint16' => [LogicalType::integer(16, false), ConvertedType::UINT_16];
+        yield 'uint32' => [LogicalType::integer(32, false), ConvertedType::UINT_32];
+        yield 'uint64' => [LogicalType::integer(64, false), ConvertedType::UINT_64];
+    }
+
+    /**
+     * @return Generator<string, array{LogicalType}>
+     */
+    public static function logical_types_without_a_converted_type(): Generator
+    {
+        yield 'uuid' => [LogicalType::uuid()];
+        yield 'float16' => [new LogicalType(LogicalType::FLOAT16)];
+        yield 'time nanos' => [new LogicalType(LogicalType::TIME, time: new Time(true, TimeUnit::NANOSECONDS))];
+        yield 'timestamp nanos' => [
+            new LogicalType(LogicalType::TIMESTAMP, timestamp: new Timestamp(true, TimeUnit::NANOSECONDS)),
+        ];
+        yield 'unknown' => [LogicalType::unknown()];
+    }
+
+    #[DataProvider('agreeing_annotations')]
+    public function test_a_logical_type_writes_its_converted_type(LogicalType $logical, ConvertedType $converted): void
+    {
+        static::assertSame($converted, $logical->convertedType());
+        static::assertSame(
+            $converted->value,
+            (new FlatColumn('c', PhysicalType::BYTE_ARRAY, logicalType: $logical))->toThrift()->converted_type,
+        );
+        static::assertSame(
+            $converted->value,
+            (new FlatColumn('c', PhysicalType::BYTE_ARRAY, $converted, $logical))->toThrift()->converted_type,
+        );
+    }
+
+    #[DataProvider('logical_types_without_a_converted_type')]
+    public function test_a_logical_type_without_a_converted_equivalent_writes_none(LogicalType $logical): void
+    {
+        static::assertNull($logical->convertedType());
+        static::assertNull((new FlatColumn(
+            'c',
+            PhysicalType::BYTE_ARRAY,
+            logicalType: $logical,
+        ))->toThrift()->converted_type);
+    }
+
+    public function test_a_converted_type_alone_is_written_as_given(): void
+    {
+        static::assertSame(
+            ConvertedType::INTERVAL->value,
+            (new FlatColumn(
+                'c',
+                PhysicalType::FIXED_LEN_BYTE_ARRAY,
+                ConvertedType::INTERVAL,
+                typeLength: 12,
+            ))->toThrift()->converted_type,
+        );
+    }
+
+    /**
+     * @return Generator<string, array{ConvertedType, LogicalType}>
+     */
+    public static function contradicting_annotations(): Generator
+    {
+        yield 'UINT_64 with INTEGER(32, signed)' => [ConvertedType::UINT_64, LogicalType::integer(32, true)];
+        yield 'UTF8 with ENUM' => [ConvertedType::UTF8, LogicalType::enum()];
+    }
+
+    #[DataProvider('contradicting_annotations')]
+    public function test_contradicting_annotations_are_refused(ConvertedType $converted, LogicalType $logical): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Column "c": converted type ' . $converted->name . ' contradicts logical type ' . $logical->name(),
+        );
+
+        new FlatColumn('c', PhysicalType::INT64, $converted, $logical);
+    }
+
+    public function test_a_leaf_without_a_physical_type_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Schema element "c" is a leaf without a physical type');
+
+        FlatColumn::fromThrift(new SchemaElement(['name' => 'c']));
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/ListElementTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/ListElementTest.php
index 4f14235f76..7c0028913c 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/ListElementTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/ListElementTest.php
@@ -5,6 +5,7 @@
 namespace Flow\Parquet\Tests\Unit\ParquetFile\Schema;
 
 use Flow\Parquet\ParquetFile\Schema\ListElement;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
@@ -18,6 +19,6 @@ public function test_decimal_element_keeps_precision_and_scale(bool $required):
 
         static::assertSame(18, $element->logicalType()?->decimalData()?->precision());
         static::assertSame(2, $element->logicalType()?->decimalData()?->scale());
-        static::assertSame(8, $element->typeLength());
+        static::assertSame(PhysicalType::INT64, $element->type());
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/LogicalType/IntegerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/LogicalType/IntegerTest.php
index 65350faebe..01f5a189c2 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/LogicalType/IntegerTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/LogicalType/IntegerTest.php
@@ -4,12 +4,14 @@
 
 namespace Flow\Parquet\Tests\Unit\ParquetFile\Schema\LogicalType;
 
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\Schema\ConvertedType;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\LogicalType\Integer;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\ThriftModel\IntType;
+use Flow\Parquet\ThriftModel\SchemaElement;
 use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
@@ -34,12 +36,12 @@ public function test_for_column_reads_the_converted_type(
         );
     }
 
-    public function test_for_column_prefers_the_converted_type_over_the_logical_integer(): void
+    public function test_for_column_reads_agreeing_converted_and_logical_annotations(): void
     {
         static::assertEquals(
             new Integer(32, false),
             Integer::forColumn(
-                new FlatColumn('i', PhysicalType::INT32, ConvertedType::UINT_32, LogicalType::integer(32, true)),
+                new FlatColumn('i', PhysicalType::INT32, ConvertedType::UINT_32, LogicalType::integer(32, false)),
             ),
         );
     }
@@ -75,4 +77,17 @@ public function test_thrift_round_trip(int $bitWidth, bool $isSigned): void
         static::assertSame($bitWidth, Integer::fromThrift($thrift)->bitWidth());
         static::assertSame($isSigned, Integer::fromThrift($thrift)->isSigned());
     }
+
+    public function test_a_footer_whose_converted_and_logical_integers_disagree_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "i": converted type UINT_32 contradicts logical type INTEGER');
+
+        FlatColumn::fromThrift(new SchemaElement([
+            'name' => 'i',
+            'type' => PhysicalType::INT32->value,
+            'converted_type' => ConvertedType::UINT_32->value,
+            'logicalType' => LogicalType::integer(32, true)->toThrift(),
+        ]));
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapKeyTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapKeyTest.php
index b35eeca07c..c3bf76459f 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapKeyTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapKeyTest.php
@@ -5,6 +5,7 @@
 namespace Flow\Parquet\Tests\Unit\ParquetFile\Schema;
 
 use Flow\Parquet\ParquetFile\Schema\MapKey;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use PHPUnit\Framework\TestCase;
 
 final class MapKeyTest extends TestCase
@@ -15,6 +16,6 @@ public function test_decimal_key_keeps_precision_and_scale(): void
 
         static::assertSame(18, $key->logicalType()?->decimalData()?->precision());
         static::assertSame(2, $key->logicalType()?->decimalData()?->scale());
-        static::assertSame(8, $key->typeLength());
+        static::assertSame(PhysicalType::INT64, $key->type());
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapValueTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapValueTest.php
index 7d726a64ac..8e29bc6a62 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapValueTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFile/Schema/MapValueTest.php
@@ -5,6 +5,7 @@
 namespace Flow\Parquet\Tests\Unit\ParquetFile\Schema;
 
 use Flow\Parquet\ParquetFile\Schema\MapValue;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
@@ -18,6 +19,6 @@ public function test_decimal_value_keeps_precision_and_scale(bool $required): vo
 
         static::assertSame(18, $value->logicalType()?->decimalData()?->precision());
         static::assertSame(2, $value->logicalType()?->decimalData()?->scale());
-        static::assertSame(8, $value->typeLength());
+        static::assertSame(PhysicalType::INT64, $value->type());
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFileTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFileTest.php
index 0df103c808..87a8a6a7e2 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFileTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/ParquetFileTest.php
@@ -6,14 +6,33 @@
 
 use Flow\Filesystem\Stream\MemorySourceStream;
 use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile;
+use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\Page\ColumnPageHeader;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
 use Flow\Parquet\Tests\Double\SpyParquetFileReader;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Writer;
 use PHPUnit\Framework\TestCase;
 
+use function array_column;
+use function array_fill;
+use function array_key_exists;
+use function array_map;
+use function count;
+use function Flow\Parquet\DSL\parquet_column;
+use function Flow\Parquet\DSL\parquet_query;
+use function intdiv;
 use function iterator_to_array;
+use function range;
 
 final class ParquetFileTest extends TestCase
 {
@@ -50,29 +69,47 @@ public function test_metadata_schema_and_reader_come_from_the_reader(): void
         static::assertSame($schema, $file->metadata()->schema());
     }
 
-    public function test_columns_reads_the_asked_columns_through_the_reader(): void
+    public function test_options_are_the_ones_the_file_was_opened_with(): void
     {
-        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')), [[
-            'name' => ['a'],
-            'id' => [1],
-        ]]);
+        $options = Options::default()->set(Option::INT_96_AS_DATETIME, false);
+
+        static::assertSame(
+            $options,
+            (new ParquetFile(
+                new MemorySourceStream('PAR1'),
+                $options,
+                new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'))),
+            ))->options(),
+        );
+    }
+
+    public function test_columns_reads_the_selected_columns_of_the_window_through_the_reader(): void
+    {
+        $reader = new SpyParquetFileReader(
+            Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+            [[
+                'name' => ['a'],
+                'id' => [1],
+            ]],
+            rows: 10,
+        );
         $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
 
         static::assertSame(
             [['name' => ['a'], 'id' => [1]]],
-            iterator_to_array($file->columns(10, [3 => 'name', 7 => 'id'], 5, 2), false),
+            iterator_to_array($file->columns(parquet_query()->select('name', 'id')->offset(2)->limit(5), 10), false),
         );
-        static::assertSame([[['name', 'id'], 10, 5, 2]], $reader->reads);
+        static::assertEquals([[['name', 'id'], 10, ReadPlan::window(10, $file->indexes(), 2, 5)]], $reader->reads);
     }
 
-    public function test_columns_without_names_reads_every_root_column(): void
+    public function test_columns_without_a_selection_reads_every_root_column(): void
     {
-        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')));
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')), rows: 4);
         $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
 
-        iterator_to_array($file->columns(10));
+        iterator_to_array($file->columns());
 
-        static::assertSame([[['id', 'name'], 10, null, null]], $reader->reads);
+        static::assertEquals([[['id', 'name'], 1024, ReadPlan::window(4, $file->indexes())]], $reader->reads);
     }
 
     public function test_columns_refuses_a_column_the_schema_lacks(): void
@@ -86,6 +123,368 @@ public function test_columns_refuses_a_column_the_schema_lacks(): void
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Column "missing" does not exist');
 
-        iterator_to_array($file->columns(10, ['missing']));
+        iterator_to_array($file->columns(parquet_query()->select('missing')));
+    }
+
+    public function test_columns_refuses_a_batch_size_below_one(): void
+    {
+        $file = new ParquetFile(
+            new MemorySourceStream('PAR1'),
+            new Options(),
+            new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'))),
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Batch size must be greater than 0');
+
+        iterator_to_array($file->columns(batchSize: 0));
+    }
+
+    public function test_a_bound_filter_is_left_to_the_reader_and_its_columns_are_not_read(): void
+    {
+        $filter = parquet_column('id')->in([2, 4]);
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')), [
+            ['name' => ['b']],
+            ['name' => ['d']],
+        ]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [['name' => 'b'], ['name' => 'd']],
+            iterator_to_array($file->values(parquet_query()->select('name')->where($filter)), false),
+        );
+        static::assertSame(['name'], $reader->reads[0][0]);
+        static::assertSame($filter, $reader->reads[0][2]->rowFilter?->filter());
+    }
+
+    public function test_a_bound_filter_plans_offset_plus_limit_rows_and_drops_the_offset(): void
+    {
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id')), [
+            ['id' => [2, 3, 4]],
+            ['id' => [5, 6]],
+            ['id' => [7]],
+        ]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+        $middle = parquet_query()
+            ->where(parquet_column('id')->greaterThan(1))
+            ->where(parquet_column('id')->lessThan(9));
+
+        static::assertSame(
+            [['id' => 4], ['id' => 5], ['id' => 6]],
+            iterator_to_array($file->values($middle->offset(2)->limit(3)), false),
+        );
+        static::assertSame(5, $reader->reads[0][2]->limit);
+        static::assertSame(2, $reader->chunksRead);
+    }
+
+    public function test_the_unbound_conjuncts_are_evaluated_on_the_rows_the_reader_returns(): void
+    {
+        $bound = parquet_column('id')->lessThan(3);
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'), FlatColumnMother::uint64('big')), [[
+            'id' => [1, 2],
+            'big' => ['5', '18446744073709551600'],
+        ]]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [['id' => 1]],
+            iterator_to_array(
+                $file->values(
+                    parquet_query()
+                        ->select('id')
+                        ->where($bound)
+                        // a float beyond 2^53 has no exact pre-image on UINT_64
+                        ->where(parquet_column('big')->lessThan(1.0e18))
+                        ->limit(5),
+                ),
+                false,
+            ),
+        );
+        static::assertSame(['id', 'big'], $reader->reads[0][0]);
+        static::assertSame($bound, $reader->reads[0][2]->rowFilter?->filter());
+        static::assertNull($reader->reads[0][2]->limit);
+    }
+
+    public function test_a_footer_recording_a_bloom_filter_length_without_its_offset_opens_and_reads(): void
+    {
+        $file = MemoryParquetFile::read(
+            Reader::php(),
+            MemoryParquetFile::bloomFilterLengthWithoutOffset(MemoryParquetFile::threeRowGroups()),
+        );
+
+        static::assertSame(
+            [1, 2, 3, 4, 5, 6],
+            array_column(iterator_to_array($file->values(parquet_query()->select('id')), false), 'id'),
+        );
+        static::assertSame(
+            [3],
+            array_column(
+                iterator_to_array(
+                    $file->values(parquet_query()->select('id')->where(parquet_column('id')->equals(3))),
+                    false,
+                ),
+                'id',
+            ),
+        );
+    }
+
+    public function test_an_in_beyond_2_pow_53_matches_ids_exactly(): void
+    {
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id')), [[
+            'id' => [9_007_199_254_740_995, 9_007_199_254_740_996, 1],
+        ]]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [['id' => 9_007_199_254_740_996]],
+            iterator_to_array(
+                $file->values(parquet_query()->where(parquet_column('id')->in([9_007_199_254_740_996, 1.0e300]))),
+                false,
+            ),
+        );
+    }
+
+    public function test_an_in_inside_2_pow_53_matches_by_key(): void
+    {
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::decimal('amount', 20, 2)), [[
+            'amount' => [1.25, 2.5, 3.75],
+        ]]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [['amount' => 1.25], ['amount' => 3.75]],
+            iterator_to_array($file->values(parquet_query()->where(parquet_column('amount')->in([1.25, 3.75]))), false),
+        );
+    }
+
+    public function test_a_filtered_read_chunks_the_matching_rows_by_the_batch_size(): void
+    {
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id')), [
+            ['id' => [2, 3, 4, 5]],
+            ['id' => [6, 7]],
+        ]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [['id' => [2, 3]], ['id' => [4, 5]], ['id' => [6, 7]]],
+            iterator_to_array($file->columns(parquet_query()->where(parquet_column('id')->greaterThan(1)), 2), false),
+        );
+    }
+
+    public function test_a_limit_of_zero_beside_a_filter_reads_nothing(): void
+    {
+        $reader = new SpyParquetFileReader(Schema::with(FlatColumn::int64('id')), [['id' => [1]]]);
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [],
+            iterator_to_array($file->values(parquet_query()->where(parquet_column('id')->equals(1))->limit(0))),
+        );
+        static::assertSame([], $reader->reads);
+    }
+
+    public function test_a_bound_filter_on_a_struct_leaf_does_not_read_its_root_column(): void
+    {
+        $reader = new SpyParquetFileReader(
+            Schema::with(FlatColumn::int64('id'), NestedColumn::struct('address', [FlatColumn::string('city')])),
+            [['id' => [1, 3]]],
+        );
+        $file = new ParquetFile(new MemorySourceStream('PAR1'), new Options(), $reader);
+
+        static::assertSame(
+            [['id' => 1], ['id' => 3]],
+            iterator_to_array(
+                $file->values(parquet_query()->select('id')->where(parquet_column('address.city')->isNotNull())),
+                false,
+            ),
+        );
+        static::assertSame(['id'], $reader->reads[0][0]);
+    }
+
+    public function test_a_filter_literal_the_column_cannot_hold_is_refused(): void
+    {
+        $file = new ParquetFile(
+            new MemorySourceStream('PAR1'),
+            new Options(),
+            new SpyParquetFileReader(Schema::with(FlatColumn::int64('id')), [['id' => [1]]]),
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "id" (INT64) cannot hold the string literal \'1\'');
+
+        iterator_to_array($file->values(parquet_query()->where(parquet_column('id')->equals('1'))));
+    }
+
+    public function test_page_headers_are_each_column_chunk_pages_labelled_with_its_column(): void
+    {
+        $file = MemoryParquetFile::read(Reader::php(), MemoryParquetFile::written(
+            Writer::php(),
+            Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+            [['id' => 1, 'name' => 'a'], ['id' => 2, 'name' => 'b']],
+        ));
+
+        static::assertSame(
+            [['id', 'id'], ['name', 'name']],
+            array_map(
+                static fn(ColumnPageHeader $header): array => [
+                    $header->column->flatPath(),
+                    $header->columnChunk->flatPath(),
+                ],
+                iterator_to_array($file->pageHeaders(), false),
+            ),
+        );
+    }
+
+    public function test_the_page_indexes_are_built_once(): void
+    {
+        $file = new ParquetFile(
+            new MemorySourceStream('PAR1'),
+            new Options(),
+            new SpyParquetFileReader(Schema::with(FlatColumn::int64('id'))),
+        );
+
+        static::assertSame($file->indexes(), $file->indexes());
+    }
+
+    public function test_a_filtered_read_reads_each_offset_index_once(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footerOnly = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $footerFile = Reader::php()->readStream($footerOnly);
+        $footerFile->reader()->footer();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $file = Reader::php()->readStream($stream);
+        $id = $file->schema()->getFlat('id');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($id);
+        $pages = $file->indexes()->offsetIndex(0, $id)->pages ?? static::fail('No offset index');
+        $read = $stream->bytes;
+
+        static::assertSame(
+            range(5, 11),
+            array_column(
+                iterator_to_array(
+                    $file->values(parquet_query()->select('id')->where(parquet_column('id')->greaterThanOrEqual(5))),
+                    false,
+                ),
+                'id',
+            ),
+        );
+        static::assertSame(
+            $footerOnly->bytes
+            + (int) $chunk->columnIndex()?->length
+            + (int) $chunk->offsetIndex()?->length
+            + $pages[2]->compressedPageSize
+            + $pages[3]->compressedPageSize
+            + $pages[4]->compressedPageSize
+            + $pages[5]->compressedPageSize,
+            $stream->bytes,
+        );
+        static::assertSame($footerOnly->bytes + (int) $chunk->offsetIndex()?->length, $read);
+    }
+
+    public function test_a_bound_filter_with_a_limit_reads_only_the_pages_up_to_the_limit(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footerOnly = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $footerFile = Reader::php()->readStream($footerOnly);
+        $footerFile->reader()->footer();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $file = Reader::php()->readStream($stream);
+        $id = $file->schema()->getFlat('id');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($id);
+        $pages = $file->indexes()->offsetIndex(0, $id)->pages ?? static::fail('No offset index');
+
+        static::assertSame(
+            [6, 7],
+            array_column(
+                iterator_to_array(
+                    $file->values(
+                        parquet_query()
+                            ->select('id')
+                            ->where(parquet_column('id')->greaterThanOrEqual(5))
+                            ->offset(1)
+                            ->limit(2),
+                    ),
+                    false,
+                ),
+                'id',
+            ),
+        );
+        static::assertSame(
+            $footerOnly->bytes
+            + (int) $chunk->columnIndex()?->length
+            + (int) $chunk->offsetIndex()?->length
+            + $pages[2]->compressedPageSize
+            + $pages[3]->compressedPageSize,
+            $stream->bytes,
+        );
+    }
+
+    public function test_a_filtered_read_on_a_struct_leaf_reads_each_page_of_the_leaf_once(): void
+    {
+        $bytes = MemoryParquetFile::written(
+            Writer::php(options: (new Options())->set(Option::PAGE_SIZE_BYTES, 16)->set(
+                Option::PAGE_SIZE_CHECK_INTERVAL,
+                2,
+            )->set(Option::COLUMNS_ENCODINGS, ['address.city' => Encodings::PLAIN])),
+            Schema::with(NestedColumn::struct('address', [FlatColumn::string('city')])),
+            array_map(static fn(int $id): array => ['address' => ['city' => 'c' . intdiv($id, 4)]], range(0, 11)),
+        );
+        $footerOnly = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $footerFile = Reader::php()->readStream($footerOnly);
+        $footerFile->reader()->footer();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $file = Reader::php()->readStream($stream);
+        $city = $file->schema()->getFlat('address.city');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($city);
+        $pages = $file->indexes()->offsetIndex(0, $city)->pages ?? static::fail('No offset index');
+        $matchingPages = 0;
+
+        foreach ($pages as $page => $location) {
+            $end = array_key_exists($page + 1, $pages) ? $pages[$page + 1]->firstRowIndex : 12;
+            $matchingPages += $location->firstRowIndex < 8 && $end > 4 ? $location->compressedPageSize : 0;
+        }
+
+        $query = parquet_query()->select('address')->where(parquet_column('address.city')->equals('c1'));
+
+        static::assertSame(array_fill(0, 4, ['address' => [
+            'city' => 'c1',
+        ]]), iterator_to_array($file->values($query), false));
+        static::assertGreaterThan(1, count($pages));
+        static::assertSame(
+            $footerOnly->bytes
+            + (int) $chunk->columnIndex()?->length
+            + (int) $chunk->offsetIndex()?->length
+            + $matchingPages,
+            $stream->bytes,
+        );
+    }
+
+    public function test_an_unfiltered_window_reads_only_the_pages_it_selects(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footerOnly = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $footerFile = Reader::php()->readStream($footerOnly);
+        $footerFile->reader()->footer();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $file = Reader::php()->readStream($stream);
+        $id = $file->schema()->getFlat('id');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($id);
+        $pages = $file->indexes()->offsetIndex(0, $id)->pages ?? static::fail('No offset index');
+
+        static::assertSame(
+            [5, 6],
+            array_column(
+                iterator_to_array($file->values(parquet_query()->select('id')->offset(5)->limit(2)), false),
+                'id',
+            ),
+        );
+        static::assertSame(
+            $footerOnly->bytes
+            + (int) $chunk->offsetIndex()?->length
+            + $pages[2]->compressedPageSize
+            + $pages[3]->compressedPageSize,
+            $stream->bytes,
+        );
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/QueryTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/QueryTest.php
new file mode 100644
index 0000000000..70505e5610
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/QueryTest.php
@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Query;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+use function Flow\Parquet\DSL\parquet_query;
+
+final class QueryTest extends TestCase
+{
+    public function test_a_new_query_reads_every_row_of_every_column(): void
+    {
+        $query = parquet_query();
+
+        static::assertSame([], $query->columns);
+        static::assertNull($query->filter);
+        static::assertSame(0, $query->offset);
+        static::assertNull($query->limit);
+    }
+
+    public function test_each_builder_step_returns_a_new_query(): void
+    {
+        $filter = parquet_column('id')->greaterThan(1);
+        $base = parquet_query();
+
+        $query = $base->select('id', 'name')->where($filter)->offset(5)->limit(10);
+
+        static::assertEquals(new Query(['id', 'name'], $filter, 5, 10), $query);
+        static::assertEquals(new Query(), $base);
+    }
+
+    public function test_a_second_filter_narrows_the_first(): void
+    {
+        $first = parquet_column('id')->greaterThan(1);
+        $second = parquet_column('id')->lessThan(9);
+
+        static::assertEquals(new All($first, $second), parquet_query()->where($first)->where($second)->filter);
+    }
+
+    public function test_each_filter_narrows_the_ones_before(): void
+    {
+        $first = parquet_column('id')->greaterThan(1);
+        $second = parquet_column('id')->lessThan(9);
+        $third = parquet_column('id')->notEquals(5);
+
+        static::assertEquals(
+            new All(new All($first, $second), $third),
+            parquet_query()->where($first)->where($second)->where($third)->filter,
+        );
+    }
+
+    public function test_select_without_columns_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A query selects at least one column');
+
+        parquet_query()->select();
+    }
+
+    public function test_an_empty_column_name_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A query column name cannot be empty');
+
+        parquet_query()->select('id', '');
+    }
+
+    public function test_a_column_selected_twice_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A query selects each column once');
+
+        parquet_query()->select('id', 'id');
+    }
+
+    #[TestWith([-1, 'Query offset must be 0 or more, got -1'])]
+    public function test_a_negative_offset_is_refused(int $offset, string $message): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($message);
+
+        parquet_query()->offset($offset);
+    }
+
+    #[TestWith([-1, 'Query limit must be 0 or more, got -1'])]
+    public function test_a_negative_limit_is_refused(int $limit, string $message): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage($message);
+
+        parquet_query()->limit($limit);
+    }
+
+    public function test_a_limit_of_zero_is_allowed(): void
+    {
+        static::assertSame(0, parquet_query()->limit(0)->limit);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnChunkReaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnChunkReaderTest.php
new file mode 100644
index 0000000000..0c20ea275b
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnChunkReaderTest.php
@@ -0,0 +1,183 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\Binary\ByteOrder;
+use Flow\Parquet\Dremel\ColumnData\ReadFlatColumnValues;
+use Flow\Parquet\Options;
+use Flow\Parquet\Reader;
+use Flow\Parquet\Reader\ColumnChunkReader;
+use Flow\Parquet\Reader\PageReader;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
+use Flow\Parquet\Tests\Mother\ColumnChunkMother;
+use PHPUnit\Framework\TestCase;
+
+use function array_keys;
+use function array_map;
+use function iterator_to_array;
+
+final class ColumnChunkReaderTest extends TestCase
+{
+    public function test_the_given_pages_are_read_in_one_call(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $id = $file->schema()->getFlat('id');
+        $offsetIndex = $file->indexes()->offsetIndex(0, $id) ?? static::fail('No offset index');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        $pages = iterator_to_array((new ColumnChunkReader(
+            new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()),
+            new Options(),
+        ))->read($file->metadata()->rowGroups()->all()[0]->getColumnChunk($id), $id, $stream, $offsetIndex, [2, 3]));
+
+        static::assertSame(
+            [4 => [4, 5], 6 => [6, 7]],
+            array_map(static fn(ReadFlatColumnValues $page): array => iterator_to_array(
+                $page->rawValues(),
+                false,
+            ), $pages),
+        );
+        static::assertSame(1, $stream->reads);
+        static::assertSame(
+            $offsetIndex->pages[2]->compressedPageSize + $offsetIndex->pages[3]->compressedPageSize,
+            $stream->bytes,
+        );
+    }
+
+    public function test_the_dictionary_page_is_read_beside_the_given_pages(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $word = $file->schema()->getFlat('word');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($word);
+        $offsetIndex = $file->indexes()->offsetIndex(0, $word) ?? static::fail('No offset index');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        $pages = iterator_to_array((new ColumnChunkReader(
+            new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()),
+            new Options(),
+        ))->read($chunk, $word, $stream, $offsetIndex, [3]));
+
+        static::assertSame(
+            [6 => ['w0', 'w1']],
+            array_map(static fn(ReadFlatColumnValues $page): array => iterator_to_array(
+                $page->rawValues(),
+                false,
+            ), $pages),
+        );
+        static::assertSame(2, $stream->reads);
+        static::assertSame(
+            $chunk->dataPageOffset() - $chunk->pageOffset() + $offsetIndex->pages[3]->compressedPageSize,
+            $stream->bytes,
+        );
+    }
+
+    public function test_a_given_dictionary_is_used_instead_of_read(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $word = $file->schema()->getFlat('word');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($word);
+        $offsetIndex = $file->indexes()->offsetIndex(0, $word) ?? static::fail('No offset index');
+        $reader = new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options());
+        $first = $reader->read($chunk, $word, new MemorySourceStream($bytes), $offsetIndex, [0]);
+        iterator_to_array($first);
+        $dictionary = $first->getReturn() ?? static::fail('No dictionary');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        $pages = iterator_to_array($reader->read($chunk, $word, $stream, $offsetIndex, [3], $dictionary));
+
+        static::assertSame(['w0', 'w1', 'w2'], $dictionary->values);
+        static::assertSame(
+            [6 => ['w0', 'w1']],
+            array_map(static fn(ReadFlatColumnValues $page): array => iterator_to_array(
+                $page->rawValues(),
+                false,
+            ), $pages),
+        );
+        static::assertSame($offsetIndex->pages[3]->compressedPageSize, $stream->bytes);
+    }
+
+    public function test_adjacent_pages_and_the_dictionary_are_read_in_one_call(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $word = $file->schema()->getFlat('word');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($word);
+        $offsetIndex = $file->indexes()->offsetIndex(0, $word) ?? static::fail('No offset index');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        iterator_to_array((new ColumnChunkReader(
+            new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()),
+            new Options(),
+        ))->read($chunk, $word, $stream, $offsetIndex, [0, 1]));
+
+        static::assertSame(1, $stream->reads);
+        static::assertSame($offsetIndex->pages[2]->offset - $chunk->pageOffset(), $stream->bytes);
+    }
+
+    public function test_a_dictionary_the_data_page_offset_points_at_is_read_beside_the_given_pages(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $word = $file->schema()->getFlat('word');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($word);
+        $offsetIndex = $file->indexes()->offsetIndex(0, $word) ?? static::fail('No offset index');
+
+        $pages = iterator_to_array((new ColumnChunkReader(
+            new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()),
+            new Options(),
+        ))->read(ColumnChunkMother::parquet816($chunk), $word, new MemorySourceStream($bytes), $offsetIndex, [3]));
+
+        static::assertSame(
+            [6 => ['w0', 'w1']],
+            array_map(static fn(ReadFlatColumnValues $page): array => iterator_to_array(
+                $page->rawValues(),
+                false,
+            ), $pages),
+        );
+    }
+
+    public function test_no_pages_read_nothing_and_return_the_given_dictionary(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $word = $file->schema()->getFlat('word');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        $pages = (new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()))->read(
+            $file->metadata()->rowGroups()->all()[0]->getColumnChunk($word),
+            $word,
+            $stream,
+            $file->indexes()->offsetIndex(0, $word),
+            [],
+        );
+
+        static::assertSame([], iterator_to_array($pages));
+        static::assertNull($pages->getReturn());
+        static::assertSame(0, $stream->reads);
+    }
+
+    public function test_without_an_offset_index_the_whole_chunk_is_read_once(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $file = MemoryParquetFile::read(Reader::php(), $bytes);
+        $id = $file->schema()->getFlat('id');
+        $chunk = $file->metadata()->rowGroups()->all()[0]->getColumnChunk($id);
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        $pages = iterator_to_array((new ColumnChunkReader(
+            new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()),
+            new Options(),
+        ))->read($chunk, $id, $stream));
+
+        static::assertSame([0, 2, 4, 6, 8, 10], array_keys($pages));
+        static::assertSame(1, $stream->reads);
+        static::assertSame($chunk->totalCompressedSize(), $stream->bytes);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnReaderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnReaderTest.php
index 6af172fd28..0da0357bbd 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnReaderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ColumnReaderTest.php
@@ -4,16 +4,27 @@
 
 namespace Flow\Parquet\Tests\Unit\Reader;
 
+use DateTimeImmutable;
 use Flow\Filesystem\Stream\MemorySourceStream;
 use Flow\Parquet\Binary\ByteOrder;
 use Flow\Parquet\Dremel\DremelAssembler;
 use Flow\Parquet\Engine\PhpParquetFileReader;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\Index\StreamIndexes;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
 use Flow\Parquet\Reader\ColumnChunkReader;
 use Flow\Parquet\Reader\ColumnReader;
 use Flow\Parquet\Reader\PageReader;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\SelectedPages;
 use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
+use Flow\Parquet\Writer;
 use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
@@ -25,44 +36,266 @@ final class ColumnReaderTest extends TestCase
     /**
      * @param list<int> $ids
      */
-    #[TestWith([null, null, [1, 2, 3, 4, 5, 6]])]
-    #[TestWith([null, 3, [4, 5, 6]])]
-    #[TestWith([2, 1, [2, 3]])]
-    #[TestWith([3, 2, [3, 4, 5]])]
-    #[TestWith([1, 5, [6]])]
-    #[TestWith([null, 6, []])]
-    public function test_a_flat_column_reads_across_row_groups(?int $limit, ?int $offset, array $ids): void
+    #[TestWith([0, [1, 2]])]
+    #[TestWith([1, [3, 4]])]
+    #[TestWith([2, [5, 6]])]
+    public function test_a_flat_column_reads_the_rows_of_one_row_group(int $group, array $ids): void
     {
         $stream = new MemorySourceStream(MemoryParquetFile::threeRowGroups());
-        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->metadata();
+        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer()->metadata();
+        $reader = new ColumnReader(
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
+            new DremelAssembler(DataConverter::initialize(new Options())),
+        );
+
+        static::assertSame(
+            array_map(static fn(int $id): array => ['id' => $id], $ids),
+            iterator_to_array(
+                $reader->readRowGroup(
+                    $metadata->schema()->get('id'),
+                    $metadata->rowGroups()->all()[$group],
+                    $group,
+                    $stream,
+                    RowSelection::all(2),
+                    new InMemoryIndexes(),
+                ),
+                false,
+            ),
+        );
+    }
 
+    /**
+     * @param list<int> $ids
+     */
+    #[TestWith([1, 0, [3]])]
+    #[TestWith([0, 1, [4]])]
+    #[TestWith([1, 1, []])]
+    public function test_a_flat_column_reads_only_the_selected_rows_of_a_row_group(
+        int $skipped,
+        int $offset,
+        array $ids,
+    ): void {
+        $stream = new MemorySourceStream(MemoryParquetFile::threeRowGroups());
+        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer()->metadata();
         $reader = new ColumnReader(
-            new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
             new DremelAssembler(DataConverter::initialize(new Options())),
         );
 
         static::assertSame(
             array_map(static fn(int $id): array => ['id' => $id], $ids),
             iterator_to_array(
-                $reader->read($metadata->schema()->get('id'), $metadata, $stream, $limit, $offset),
+                $reader->readRowGroup(
+                    $metadata->schema()->get('id'),
+                    $metadata->rowGroups()->all()[1],
+                    1,
+                    $stream,
+                    RowSelection::window(2, $offset, 2 - $offset - $skipped),
+                    new InMemoryIndexes(),
+                ),
                 false,
             ),
         );
     }
 
-    public function test_a_nested_column_reads_across_row_groups(): void
+    public function test_a_nested_column_reads_the_rows_of_one_row_group(): void
     {
         $stream = new MemorySourceStream(MemoryParquetFile::threeRowGroups());
-        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->metadata();
+        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer()->metadata();
+        $reader = new ColumnReader(
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
+            new DremelAssembler(DataConverter::initialize(new Options())),
+        );
+
+        static::assertSame(
+            [['tags' => ['t4']]],
+            iterator_to_array(
+                $reader->readRowGroup(
+                    $metadata->schema()->get('tags'),
+                    $metadata->rowGroups()->all()[1],
+                    1,
+                    $stream,
+                    RowSelection::window(2, 1),
+                    new InMemoryIndexes(),
+                ),
+                false,
+            ),
+        );
+    }
 
+    public function test_a_nested_leaf_keeps_only_the_masked_rows_inside_a_page(): void
+    {
+        $stream = new MemorySourceStream(MemoryParquetFile::pagedColumns());
+        $footer = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer();
+        $metadata = $footer->metadata();
         $reader = new ColumnReader(
-            new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
             new DremelAssembler(DataConverter::initialize(new Options())),
         );
+        $selection = RowSelection::window(12, 2, 5)->masked([false, true, false, true, false]);
 
         static::assertSame(
-            array_map(static fn(int $id): array => ['tags' => ['t' . $id]], [2, 3, 4]),
-            iterator_to_array($reader->read($metadata->schema()->get('tags'), $metadata, $stream, 3, 1), false),
+            [['tags' => [3]], ['tags' => [5, 5, 5]]],
+            iterator_to_array(
+                $reader->readRowGroup(
+                    $metadata->schema()->get('tags'),
+                    $metadata->rowGroups()->all()[0],
+                    0,
+                    $stream,
+                    $selection,
+                    new StreamIndexes($footer, $stream),
+                ),
+                false,
+            ),
+        );
+        static::assertSame(
+            [['id' => 3], ['id' => 5]],
+            iterator_to_array(
+                $reader->readRowGroup(
+                    $metadata->schema()->get('id'),
+                    $metadata->rowGroups()->all()[0],
+                    0,
+                    $stream,
+                    $selection,
+                    new StreamIndexes($footer, $stream),
+                ),
+                false,
+            ),
+        );
+    }
+
+    public function test_physical_values_are_undecoded_and_null_where_the_leaf_or_its_struct_is_null_beside_the_pages_decoded(): void
+    {
+        $stream = new MemorySourceStream(MemoryParquetFile::written(
+            Writer::php(),
+            Schema::with(FlatColumn::date('day'), NestedColumn::struct('address', [FlatColumn::string('city')])),
+            [
+                ['day' => new DateTimeImmutable('1970-01-02 UTC'), 'address' => ['city' => 'a']],
+                ['day' => null, 'address' => null],
+                ['day' => new DateTimeImmutable('1970-01-04 UTC'), 'address' => ['city' => null]],
+                ['day' => new DateTimeImmutable('1970-01-05 UTC'), 'address' => ['city' => 'b']],
+            ],
+        ));
+        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer()->metadata();
+        $reader = new ColumnReader(
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
+            new DremelAssembler(DataConverter::initialize(new Options())),
+        );
+        $selection = RowSelection::window(4, 0, 3);
+        $day = $reader->readPhysical(
+            $metadata->schema()->getFlat('day'),
+            $metadata->rowGroups()->all()[0],
+            0,
+            $stream,
+            $selection,
+            new InMemoryIndexes(),
+        );
+
+        static::assertSame(
+            [
+                0 => [
+                    'values' => [1, 3, 4],
+                    'definitionLevels' => [1, 0, 1, 1],
+                ],
+            ],
+            $day['chunk']['pages'],
+        );
+        static::assertSame([1, null, 3], $day['values']);
+        static::assertSame(
+            ['a', null, null],
+            $reader->readPhysical(
+                $metadata->schema()->getFlat('address.city'),
+                $metadata->rowGroups()->all()[0],
+                0,
+                $stream,
+                $selection,
+                new InMemoryIndexes(),
+            )['values'],
+        );
+        static::assertSame(
+            ['chunk' => ['pages' => [], 'dictionary' => null], 'values' => []],
+            $reader->readPhysical(
+                $metadata->schema()->getFlat('day'),
+                $metadata->rowGroups()->all()[0],
+                0,
+                $stream,
+                RowSelection::none(4),
+                new InMemoryIndexes(),
+            ),
+        );
+    }
+
+    public function test_the_dictionary_read_for_the_physical_values_is_not_read_again_for_the_output(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footer = (new PhpParquetFileReader(
+            new MemorySourceStream($bytes),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        ))->footer();
+        $indexes = new StreamIndexes($footer, new MemorySourceStream($bytes));
+        $word = $footer->metadata()->schema()->getFlat('word');
+        $rowGroup = $footer->metadata()->rowGroups()->all()[0];
+        $offsetIndex = $indexes->offsetIndex(0, $word) ?? static::fail('No offset index');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $reader = new ColumnReader(
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
+            new DremelAssembler(DataConverter::initialize(new Options())),
+        );
+
+        $physical = $reader->readPhysical($word, $rowGroup, 0, $stream, RowSelection::window(12, 6, 2), $indexes);
+        $read = $stream->bytes;
+
+        static::assertSame(
+            [['word' => 'w0'], ['word' => 'w1'], ['word' => 'w2'], ['word' => 'w0']],
+            iterator_to_array($reader->readRowGroup(
+                $word,
+                $rowGroup,
+                0,
+                $stream,
+                RowSelection::window(12, 6, 4),
+                $indexes,
+                ['word' => $physical['chunk']],
+            ), false),
+        );
+        static::assertSame($offsetIndex->pages[4]->compressedPageSize, $stream->bytes - $read);
+    }
+
+    public function test_physical_values_of_a_repeated_leaf_are_refused(): void
+    {
+        $stream = new MemorySourceStream(MemoryParquetFile::threeRowGroups());
+        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer()->metadata();
+        $reader = new ColumnReader(
+            new SelectedPages(
+                new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+            ),
+            new DremelAssembler(DataConverter::initialize(new Options())),
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Column "tags.list.element" lies inside a list or a map, where a row holds no single value',
+        );
+
+        $reader->readPhysical(
+            $metadata->schema()->getFlat('tags.list.element'),
+            $metadata->rowGroups()->all()[0],
+            0,
+            $stream,
+            RowSelection::all(2),
+            new InMemoryIndexes(),
         );
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/FilteredBatchesTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/FilteredBatchesTest.php
new file mode 100644
index 0000000000..b939d97481
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/FilteredBatchesTest.php
@@ -0,0 +1,159 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Evaluation\FilterEvaluator;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\NestedColumn;
+use Flow\Parquet\Reader\FilteredBatches;
+use Generator;
+use PHPUnit\Framework\TestCase;
+
+use function array_map;
+use function Flow\Parquet\DSL\parquet_column;
+use function iterator_to_array;
+
+final class FilteredBatchesTest extends TestCase
+{
+    public function test_the_batches_hold_the_returned_columns_and_the_filters_root_columns(): void
+    {
+        $batches = new FilteredBatches(
+            new FilterEvaluator(BoundFilter::bind(
+                parquet_column('address.city')->equals('x'),
+                Schema::with(FlatColumn::int64('id'), NestedColumn::struct('address', [FlatColumn::string('city')])),
+                new Options(),
+            )),
+            ['id'],
+        );
+
+        static::assertSame(['id', 'address'], $batches->columns());
+    }
+
+    public function test_only_the_matching_rows_of_the_returned_columns_are_kept(): void
+    {
+        $batches = new FilteredBatches(
+            new FilterEvaluator(BoundFilter::bind(
+                parquet_column('id')->in([2, 4]),
+                Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+                new Options(),
+            )),
+            ['name'],
+        );
+
+        static::assertSame(
+            [['name' => ['b', 'd']]],
+            iterator_to_array($batches->filter([
+                ['id' => [1, 2, 3], 'name' => ['a', 'b', 'c']],
+                ['id' => [4], 'name' => ['d']],
+            ]), false),
+        );
+    }
+
+    public function test_without_an_evaluator_every_row_is_kept_and_only_the_offset_and_the_limit_apply(): void
+    {
+        $batches = new FilteredBatches(null, ['id'], 1, 2);
+
+        static::assertSame(['id'], $batches->columns());
+        static::assertSame(
+            [['id' => [2, 3]]],
+            iterator_to_array($batches->filter([['id' => [1, 2]], ['id' => [3, 4]]]), false),
+        );
+    }
+
+    public function test_offset_and_limit_count_the_matching_rows_across_batches_and_no_batch_is_pulled_past_the_limit(): void
+    {
+        $pulled = 0;
+        $source = (
+            /** @return Generator<int, array<string, list<mixed>>> */
+            static function () use (&$pulled): Generator {
+                foreach ([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]] as $ids) {
+                    $pulled++;
+
+                    yield ['id' => $ids, 'name' => array_map('strval', $ids)];
+                }
+            }
+        )();
+
+        $batches = new FilteredBatches(
+            new FilterEvaluator(BoundFilter::bind(
+                parquet_column('id')->greaterThan(1),
+                Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+                new Options(),
+            )),
+            ['id'],
+            offset: 2,
+            limit: 3,
+        );
+
+        static::assertSame([['id' => [4, 5, 6]]], iterator_to_array($batches->filter($source), false));
+        static::assertSame(2, $pulled);
+    }
+
+    public function test_the_matching_rows_are_rechunked_to_the_batch_size(): void
+    {
+        $batches = new FilteredBatches(
+            new FilterEvaluator(BoundFilter::bind(
+                parquet_column('id')->greaterThan(1),
+                Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+                new Options(),
+            )),
+            ['id'],
+            batchSize: 2,
+        );
+
+        static::assertSame(
+            [['id' => [2, 3]], ['id' => [4, 5]], ['id' => [6, 7]], ['id' => [8]]],
+            iterator_to_array($batches->filter([
+                ['id' => [1, 2, 3, 4, 5], 'name' => ['', '', '', '', '']],
+                ['id' => [6, 7, 8], 'name' => ['', '', '']],
+            ]), false),
+        );
+    }
+
+    public function test_a_limit_of_zero_pulls_no_batch(): void
+    {
+        $pulled = 0;
+        $source = (
+            /** @return Generator<int, array<string, list<mixed>>> */
+            static function () use (&$pulled): Generator {
+                $pulled++;
+
+                yield ['id' => [2], 'name' => ['']];
+            }
+        )();
+
+        $batches = new FilteredBatches(
+            new FilterEvaluator(BoundFilter::bind(
+                parquet_column('id')->greaterThan(1),
+                Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+                new Options(),
+            )),
+            ['id'],
+            limit: 0,
+        );
+
+        static::assertSame([], iterator_to_array($batches->filter($source)));
+        static::assertSame(0, $pulled);
+    }
+
+    public function test_no_returned_column_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A filtered read returns at least one column');
+
+        new FilteredBatches(
+            new FilterEvaluator(BoundFilter::bind(
+                parquet_column('id')->isNull(),
+                Schema::with(FlatColumn::int64('id'), FlatColumn::string('name')),
+                new Options(),
+            )),
+            [],
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/PageRunTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/PageRunTest.php
new file mode 100644
index 0000000000..24497f539f
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/PageRunTest.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\Reader\PageRun;
+use PHPUnit\Framework\TestCase;
+
+final class PageRunTest extends TestCase
+{
+    public function test_an_extended_run_keeps_its_start(): void
+    {
+        $run = (new PageRun(100, 120))->extendedTo(150);
+
+        static::assertSame([100, 150, 50], [$run->start, $run->end, $run->length]);
+    }
+
+    public function test_a_run_of_no_bytes_is_refused(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('The offset index locates a page of no bytes at offset 100');
+
+        new PageRun(100, 100);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/BloomFilterPrunerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/BloomFilterPrunerTest.php
new file mode 100644
index 0000000000..b28043f7c6
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/BloomFilterPrunerTest.php
@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader\Pruning;
+
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\MetadataRowGroupChunks;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader\Pruning\BloomFilterPruner;
+use Flow\Parquet\Reader\Pruning\PrunedRows;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Mother\FooterMother;
+use Flow\Parquet\Tests\Mother\SbbfMother;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class BloomFilterPrunerTest extends TestCase
+{
+    public function test_a_group_whose_filter_lacks_the_literal_is_dropped_and_matched_is_kept(): void
+    {
+        $footer = FooterMother::idGroups([0, 10], [0, 10], [0, 10]);
+        $id = FlatColumn::int64('id');
+        $indexes = new InMemoryIndexes(bloomFilters: ['id' => [
+            SbbfMother::with($id, 0, 10),
+            SbbfMother::with($id, 4, 10),
+            SbbfMother::with($id, 0, 10),
+        ]]);
+        $matched = new RowSelection(new RowSelector(2, true), new RowSelector(2, false), new RowSelector(2, true));
+
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(2, true), new RowSelector(2, false), new RowSelector(2, true)),
+                $matched,
+            ),
+            (new BloomFilterPruner(new MetadataRowGroupChunks($footer->metadata()), $indexes))->prune(
+                BoundFilter::bind(parquet_column('id')->equals(4), $footer->schema(), new Options()),
+                new PrunedRows(RowSelection::all(6), $matched),
+            ),
+        );
+    }
+
+    public function test_no_filter_is_read_for_a_range_predicate(): void
+    {
+        $footer = FooterMother::idGroups([0, 10], [0, 10]);
+        $indexes = new InMemoryIndexes(bloomFilters: ['id' => [
+            SbbfMother::with(FlatColumn::int64('id'), 0),
+            SbbfMother::with(FlatColumn::int64('id'), 0),
+        ]]);
+        $rows = new PrunedRows(RowSelection::all(4), RowSelection::none(4));
+
+        static::assertEquals($rows, (new BloomFilterPruner(
+            new MetadataRowGroupChunks($footer->metadata()),
+            $indexes,
+        ))->prune(BoundFilter::bind(parquet_column('id')->greaterThan(4), $footer->schema(), new Options()), $rows));
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_a_group_selecting_no_row_or_matched_already_reads_no_filter(): void
+    {
+        $footer = FooterMother::idGroups([0, 10], [0, 10], [0, 10]);
+        $indexes = new InMemoryIndexes(bloomFilters: ['id' => [
+            SbbfMother::with(FlatColumn::int64('id'), 0),
+            SbbfMother::with(FlatColumn::int64('id'), 0),
+            SbbfMother::with(FlatColumn::int64('id'), 0),
+        ]]);
+        $selected = new RowSelection(new RowSelector(2, true), new RowSelector(4, false));
+        $matched = new RowSelection(new RowSelector(2, true), new RowSelector(2, false), new RowSelector(2, true));
+
+        static::assertEquals(
+            new PrunedRows($matched, $matched),
+            (new BloomFilterPruner(new MetadataRowGroupChunks($footer->metadata()), $indexes))->prune(
+                BoundFilter::bind(parquet_column('id')->equals(4), $footer->schema(), new Options()),
+                new PrunedRows($selected, $matched),
+            ),
+        );
+        static::assertSame([['bloomFilter', 'id', 2]], $indexes->reads);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/PageIndexPrunerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/PageIndexPrunerTest.php
new file mode 100644
index 0000000000..443894c520
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/PageIndexPrunerTest.php
@@ -0,0 +1,168 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader\Pruning;
+
+use Flow\Parquet\Reader\Pruning\PrunedRows;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+use Flow\Parquet\Tests\Context\OneGroupPagePruning;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Mother\PageIndexMother;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class PageIndexPrunerTest extends TestCase
+{
+    public function test_columns_whose_pages_break_at_other_rows_are_evaluated_over_the_rows_their_pages_share(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(5, true), new RowSelector(2, false), new RowSelector(3, true)),
+                new RowSelection(new RowSelector(5, true), new RowSelector(2, false), new RowSelector(3, true)),
+            ),
+            OneGroupPagePruning::pruned(
+                parquet_column('a')->greaterThanOrEqual(5)->and(parquet_column('b')->lessThan(107)),
+                new InMemoryIndexes([
+                    'a' => [PageIndexMother::int64([[0, 4], [5, 9]])],
+                    'b' => [PageIndexMother::int64([[100, 102], [103, 106], [107, 109]])],
+                ], ['a' => [PageIndexMother::pagesAt(0, 5)], 'b' => [PageIndexMother::pagesAt(0, 3, 7)]]),
+            ),
+        );
+    }
+
+    public function test_only_the_rows_of_pages_that_always_match_are_matched(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(5, true), new RowSelector(5, false)),
+                new RowSelection(new RowSelector(7, true), new RowSelector(3, false)),
+            ),
+            OneGroupPagePruning::pruned(
+                parquet_column('a')->greaterThanOrEqual(5),
+                new InMemoryIndexes(['a' => [PageIndexMother::int64([[0, 4], [5, 6], [7, 9]], [
+                    0,
+                    1,
+                    0,
+                ])]], ['a' => [PageIndexMother::pagesAt(0, 5, 7)]]),
+            ),
+        );
+    }
+
+    public function test_is_null_keeps_every_page_holding_a_null_and_is_not_null_every_page_holding_a_value(): void
+    {
+        $indexes = new InMemoryIndexes(['a' => [PageIndexMother::int64([[0, 3], [4, 5], null], [0, 1, 3])]], [
+            'a' => [PageIndexMother::pagesAt(0, 4, 7)],
+        ]);
+
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(4, true), new RowSelector(6, false)),
+                new RowSelection(new RowSelector(7, true), new RowSelector(3, false)),
+            ),
+            OneGroupPagePruning::pruned(parquet_column('a')->isNull(), $indexes),
+        );
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(7, false), new RowSelector(3, true)),
+                new RowSelection(new RowSelector(4, false), new RowSelector(6, true)),
+            ),
+            OneGroupPagePruning::pruned(parquet_column('a')->isNotNull(), $indexes),
+        );
+    }
+
+    public function test_a_null_page_never_matches_a_comparison(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(5, false), new RowSelector(5, true)),
+                RowSelection::none(10),
+            ),
+            OneGroupPagePruning::pruned(
+                parquet_column('a')->lessThan(100),
+                new InMemoryIndexes(['a' => [PageIndexMother::int64([
+                    [0, 200],
+                    null,
+                ])]], ['a' => [PageIndexMother::pagesAt(0, 5)]]),
+            ),
+        );
+    }
+
+    public function test_a_filtered_column_without_an_index_keeps_the_whole_group(): void
+    {
+        $rows = new PrunedRows(RowSelection::window(10, 1), RowSelection::none(10));
+
+        static::assertEquals($rows, OneGroupPagePruning::pruned(
+            parquet_column('a')->greaterThanOrEqual(5)->and(parquet_column('b')->lessThan(107)),
+            new InMemoryIndexes(['a' => [PageIndexMother::int64([[0, 4], [5, 9]])]], [
+                'a' => [PageIndexMother::pagesAt(0, 5)],
+                'b' => [PageIndexMother::pagesAt(0, 3, 7)],
+            ]),
+            $rows,
+        ));
+    }
+
+    public function test_the_pruned_rows_stay_inside_the_rows_given(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(5, true), new RowSelector(3, false), new RowSelector(2, true)),
+                new RowSelection(new RowSelector(5, true), new RowSelector(3, false), new RowSelector(2, true)),
+            ),
+            OneGroupPagePruning::pruned(
+                parquet_column('a')->greaterThanOrEqual(5),
+                new InMemoryIndexes(['a' => [PageIndexMother::int64([
+                    [0, 4],
+                    [5, 9],
+                ])]], ['a' => [PageIndexMother::pagesAt(0, 5)]]),
+                new PrunedRows(RowSelection::window(10, 3, 5), RowSelection::none(10)),
+            ),
+        );
+    }
+
+    public function test_a_group_without_a_selected_row_reads_no_index(): void
+    {
+        $indexes = new InMemoryIndexes();
+
+        OneGroupPagePruning::pruned(
+            parquet_column('a')->greaterThanOrEqual(5),
+            $indexes,
+            new PrunedRows(RowSelection::none(10), RowSelection::none(10)),
+        );
+
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_a_group_whose_selected_rows_are_all_matched_reads_no_index(): void
+    {
+        $indexes = new InMemoryIndexes(['a' => [PageIndexMother::int64([
+            [0, 4],
+            [5, 9],
+        ])]], ['a' => [PageIndexMother::pagesAt(0, 5)]]);
+        $rows = new PrunedRows(RowSelection::window(10, 2), RowSelection::window(10, 2));
+
+        static::assertEquals($rows, OneGroupPagePruning::pruned(
+            parquet_column('a')->greaterThanOrEqual(5),
+            $indexes,
+            $rows,
+        ));
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_a_column_index_and_offset_index_of_different_page_counts_keep_the_whole_group(): void
+    {
+        $rows = new PrunedRows(RowSelection::all(10), RowSelection::none(10));
+
+        static::assertEquals($rows, OneGroupPagePruning::pruned(
+            parquet_column('a')->greaterThanOrEqual(5),
+            new InMemoryIndexes(['a' => [PageIndexMother::int64([[0, 4], [5, 9]])]], ['a' => [PageIndexMother::pagesAt(
+                0,
+                3,
+                5,
+            )]]),
+            $rows,
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/RowGroupStatisticsPrunerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/RowGroupStatisticsPrunerTest.php
new file mode 100644
index 0000000000..a9ad43afac
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/Pruning/RowGroupStatisticsPrunerTest.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader\Pruning;
+
+use Flow\Parquet\Reader\Pruning\PrunedRows;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+use Flow\Parquet\Tests\Context\ThreeRowGroupsPruning;
+use Flow\Parquet\Tests\Double\RowGroupChunksSpy;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class RowGroupStatisticsPrunerTest extends TestCase
+{
+    public function test_a_group_that_never_matches_is_skipped_and_one_that_always_matches_is_matched(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(2, true), new RowSelector(4, false)),
+                new RowSelection(new RowSelector(4, true), new RowSelector(2, false)),
+            ),
+            ThreeRowGroupsPruning::pruned(parquet_column('id')->greaterThan(3), RowSelection::all(6)),
+        );
+    }
+
+    public function test_the_pruned_rows_stay_inside_the_rows_given(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(2, true), new RowSelector(1, false), new RowSelector(3, true)),
+                new RowSelection(new RowSelector(6, true)),
+            ),
+            ThreeRowGroupsPruning::pruned(parquet_column('id')->greaterThan(3), RowSelection::window(6, 1, 2)),
+        );
+    }
+
+    public function test_the_rows_matched_before_stay_matched_inside_the_selection(): void
+    {
+        static::assertEquals(
+            new PrunedRows(
+                new RowSelection(new RowSelector(2, true), new RowSelector(4, false)),
+                new RowSelection(
+                    new RowSelector(2, true),
+                    new RowSelector(1, false),
+                    new RowSelector(1, true),
+                    new RowSelector(2, false),
+                ),
+            ),
+            ThreeRowGroupsPruning::pruned(
+                parquet_column('id')->greaterThan(3),
+                RowSelection::all(6),
+                new RowSelection(new RowSelector(3, false), new RowSelector(3, true)),
+            ),
+        );
+    }
+
+    public function test_a_group_without_a_selected_row_is_not_evaluated(): void
+    {
+        $chunks = new RowGroupChunksSpy(ThreeRowGroupsPruning::chunks());
+
+        ThreeRowGroupsPruning::pruned(
+            parquet_column('id')->greaterThan(3),
+            RowSelection::window(6, 2, 2),
+            null,
+            $chunks,
+        );
+
+        static::assertSame([1], $chunks->chunkReads);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ReadPlanTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ReadPlanTest.php
new file mode 100644
index 0000000000..f2e456c5f8
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ReadPlanTest.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use PHPUnit\Framework\TestCase;
+
+final class ReadPlanTest extends TestCase
+{
+    public function test_matched_rows_over_another_row_count_are_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A read plan selection and its matched rows must cover the same rows');
+
+        new ReadPlan(RowSelection::all(3), RowSelection::all(2), new InMemoryIndexes());
+    }
+
+    public function test_matched_rows_outside_the_selection_are_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A read plan can match only rows it selects');
+
+        new ReadPlan(RowSelection::window(5, 2), RowSelection::all(5), new InMemoryIndexes());
+    }
+
+    public function test_a_window_plan_reads_and_matches_the_window(): void
+    {
+        static::assertEquals(
+            new ReadPlan(
+                RowSelection::window(5, 1, 2),
+                RowSelection::window(5, 1, 2),
+                $indexes = new InMemoryIndexes(),
+            ),
+            ReadPlan::window(5, $indexes, 1, 2),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ReadPlannerTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ReadPlannerTest.php
new file mode 100644
index 0000000000..c6f531e3a3
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/ReadPlannerTest.php
@@ -0,0 +1,214 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Filter\All;
+use Flow\Parquet\Filter\Binding\BoundFilter;
+use Flow\Parquet\Filter\Filter;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Reader\ReadPlan;
+use Flow\Parquet\Reader\ReadPlanner;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Double\SpyFooter;
+use Flow\Parquet\Tests\Mother\FooterMother;
+use Flow\Parquet\Tests\Mother\PageIndexMother;
+use Flow\Parquet\Tests\Mother\ReadPlanMother;
+use Flow\Parquet\Tests\Mother\SbbfMother;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+use function Flow\Parquet\DSL\parquet_column;
+
+final class ReadPlannerTest extends TestCase
+{
+    public function test_without_a_filter_the_window_is_read_and_matched_and_no_statistics_are_read(): void
+    {
+        $footer = new SpyFooter(Schema::with(FlatColumn::int64('id')), 10);
+        $indexes = new InMemoryIndexes();
+
+        static::assertEquals(
+            ReadPlanMother::window(10, 2, 5),
+            (new ReadPlanner())->plan($footer, $indexes, null, 2, 5),
+        );
+        static::assertSame([], $footer->rowGroupChunkReads);
+        static::assertSame([], $indexes->reads);
+    }
+
+    public function test_a_limit_beside_a_wholly_bound_filter_counts_the_rows_the_row_filter_keeps(): void
+    {
+        $footer = FooterMother::idGroups([1, 2], [3, 4], [5, 6]);
+        $filter = BoundFilter::bind(parquet_column('id')->greaterThan(1), $footer->schema(), new Options());
+
+        $plan = (new ReadPlanner())->plan($footer, new InMemoryIndexes(), $filter, 1, 3);
+
+        static::assertEquals(RowSelection::window(6, 1), $plan->selection);
+        static::assertSame($filter, $plan->rowFilter);
+        static::assertSame(3, $plan->limit);
+    }
+
+    public function test_a_limit_beside_an_empty_all_reads_the_window_without_a_row_filter(): void
+    {
+        $footer = FooterMother::idGroups([1, 2], [3, 4], [5, 6]);
+
+        $plan = (new ReadPlanner())->plan(
+            $footer,
+            new InMemoryIndexes(),
+            BoundFilter::bind(new All(), $footer->schema(), new Options()),
+            0,
+            2,
+        );
+
+        static::assertEquals(RowSelection::all(6), $plan->selection);
+        static::assertNull($plan->rowFilter);
+        static::assertSame(2, $plan->limit);
+    }
+
+    public function test_a_filtered_plan_without_a_limit_carries_the_row_filter_and_no_limit(): void
+    {
+        $footer = FooterMother::idGroups([1, 2], [3, 4], [5, 6]);
+        $kept = parquet_column('id')->equals(1);
+
+        $plan = (new ReadPlanner())->plan(
+            $footer,
+            new InMemoryIndexes(),
+            BoundFilter::bind($kept->and(parquet_column('id')->equals('1')), $footer->schema(), new Options()),
+        );
+
+        static::assertSame($kept, $plan->rowFilter?->filter());
+        static::assertNull($plan->limit);
+    }
+
+    /**
+     * @return Generator<string, array{Filter}>
+     */
+    public static function filters_not_wholly_bound(): Generator
+    {
+        yield 'partly bound' => [parquet_column('id')->equals(1)->and(parquet_column('id')->equals('1'))];
+        yield 'unbound' => [parquet_column('id')->equals('1')];
+    }
+
+    #[DataProvider('filters_not_wholly_bound')]
+    public function test_a_limit_beside_a_filter_not_wholly_bound_is_refused(Filter $filter): void
+    {
+        $footer = new SpyFooter(Schema::with(FlatColumn::int64('id')), 10);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'A limit counts the rows returned, which a plan cannot honour unless the file answers every conjunct of '
+            . 'its filter exactly',
+        );
+
+        (new ReadPlanner())->plan(
+            $footer,
+            new InMemoryIndexes(),
+            BoundFilter::bind($filter, $footer->schema(), new Options()),
+            0,
+            10,
+        );
+    }
+
+    public function test_a_limit_of_zero_beside_a_filter_reads_no_row_and_no_footer_statistics(): void
+    {
+        $footer = new SpyFooter(Schema::with(FlatColumn::int64('id')), 10);
+
+        static::assertEquals(
+            ReadPlanMother::window(10, 0, 0),
+            (new ReadPlanner())->plan(
+                $footer,
+                new InMemoryIndexes(),
+                BoundFilter::bind(parquet_column('id')->equals(1), $footer->schema(), new Options()),
+                limit: 0,
+            ),
+        );
+        static::assertSame([], $footer->rowGroupChunkReads);
+    }
+
+    public function test_a_group_the_bloom_filter_drops_reads_no_page_index(): void
+    {
+        $footer = FooterMother::idGroups([0, 10], [0, 10]);
+        $id = FlatColumn::int64('id');
+        $indexes = new InMemoryIndexes(
+            ['id' => [PageIndexMother::int64([[0, 10]]), PageIndexMother::int64([[0, 10]])]],
+            ['id' => [PageIndexMother::pagesAt(0), PageIndexMother::pagesAt(0)]],
+            ['id' => [SbbfMother::with($id, 0, 10), SbbfMother::with($id, 4)]],
+        );
+
+        static::assertEquals(
+            new RowSelection(new RowSelector(2, true), new RowSelector(2, false)),
+            (new ReadPlanner())->plan(
+                $footer,
+                $indexes,
+                BoundFilter::bind(parquet_column('id')->equals(4), $footer->schema(), new Options()),
+            )->selection,
+        );
+        static::assertSame(
+            [
+                ['bloomFilter', 'id', 0],
+                ['bloomFilter', 'id', 1],
+                ['columnIndex', 'id', 1],
+                ['offsetIndex', 'id', 1],
+            ],
+            $indexes->reads,
+        );
+    }
+
+    public function test_a_filter_asks_the_footer_for_the_bound_columns_only(): void
+    {
+        $id = FlatColumn::int64('id');
+        $footer = new SpyFooter(Schema::with($id, FlatColumn::string('name')));
+
+        (new ReadPlanner())->plan(
+            $footer,
+            new InMemoryIndexes(),
+            BoundFilter::bind(
+                parquet_column('id')->greaterThan(1)->and(parquet_column('missing')->isNull()),
+                $footer->schema(),
+                new Options(),
+            ),
+        );
+
+        static::assertEquals([[$id]], $footer->rowGroupChunkReads);
+    }
+
+    public function test_the_row_groups_statistics_narrow_the_window_from_its_offset_in_raw_rows(): void
+    {
+        $footer = FooterMother::idGroups([1, 2], [3, 4], [5, 6]);
+        $filter = BoundFilter::bind(parquet_column('id')->greaterThan(2), $footer->schema(), new Options());
+        $kept = new RowSelection(new RowSelector(2, true), new RowSelector(4, false));
+        $fromThird = new RowSelection(new RowSelector(3, true), new RowSelector(3, false));
+        $indexes = new InMemoryIndexes();
+
+        static::assertEquals(
+            new ReadPlan($kept, $kept, $indexes, $filter),
+            (new ReadPlanner())->plan($footer, $indexes, $filter),
+        );
+        static::assertEquals(
+            new ReadPlan($fromThird, $fromThird, $indexes, $filter),
+            (new ReadPlanner())->plan($footer, $indexes, $filter, 3),
+        );
+    }
+
+    public function test_the_page_index_narrows_the_row_groups_the_statistics_keep(): void
+    {
+        $footer = FooterMother::oneGroup(10, FlatColumn::int64('a'));
+        $pages = new RowSelection(new RowSelector(5, true), new RowSelector(5, false));
+
+        $indexes = new InMemoryIndexes(['a' => [PageIndexMother::int64([
+            [0, 4],
+            [5, 9],
+        ])]], ['a' => [PageIndexMother::pagesAt(0, 5)]]);
+        $filter = BoundFilter::bind(parquet_column('a')->greaterThanOrEqual(5), $footer->schema(), new Options());
+        $plan = (new ReadPlanner())->plan($footer, $indexes, $filter);
+
+        static::assertEquals(new ReadPlan($pages, $pages, $indexes, $filter), $plan);
+        static::assertSame($indexes, $plan->indexes);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/RowSelectionTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/RowSelectionTest.php
new file mode 100644
index 0000000000..6597697c12
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/RowSelectionTest.php
@@ -0,0 +1,267 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\RowSelector;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function array_map;
+
+final class RowSelectionTest extends TestCase
+{
+    /**
+     * @param list<array{0: int, 1: bool}> $selectors
+     */
+    #[TestWith([0, null, [[10, false]]])]
+    #[TestWith([3, null, [[3, true], [7, false]]])]
+    #[TestWith([3, 4, [[3, true], [4, false], [3, true]]])]
+    #[TestWith([0, 0, [[10, true]]])]
+    #[TestWith([10, 5, [[10, true]]])]
+    #[TestWith([12, null, [[10, true]]])]
+    #[TestWith([8, 5, [[8, true], [2, false]]])]
+    public function test_a_window_skips_the_offset_and_selects_up_to_the_limit(
+        int $offset,
+        ?int $limit,
+        array $selectors,
+    ): void {
+        static::assertEquals(
+            new RowSelection(...array_map(
+                static fn(array $selector): RowSelector => new RowSelector(...$selector),
+                $selectors,
+            )),
+            RowSelection::window(10, $offset, $limit),
+        );
+        static::assertSame(10, RowSelection::window(10, $offset, $limit)->totalRows());
+    }
+
+    public function test_adjacent_selectors_are_merged_and_empty_ones_dropped(): void
+    {
+        $selection = new RowSelection(
+            new RowSelector(2, true),
+            new RowSelector(0, false),
+            new RowSelector(3, true),
+            new RowSelector(1, false),
+            new RowSelector(4, false),
+        );
+
+        static::assertEquals([new RowSelector(5, true), new RowSelector(5, false)], $selection->selectors());
+    }
+
+    public function test_the_intersection_selects_the_rows_both_select(): void
+    {
+        $left = new RowSelection(new RowSelector(4, false), new RowSelector(4, true), new RowSelector(2, false));
+        $right = new RowSelection(new RowSelector(2, true), new RowSelector(7, false), new RowSelector(1, true));
+
+        static::assertEquals(
+            new RowSelection(
+                new RowSelector(2, true),
+                new RowSelector(2, false),
+                new RowSelector(4, true),
+                new RowSelector(1, false),
+                new RowSelector(1, true),
+            ),
+            $left->intersection($right),
+        );
+        static::assertEquals($left->intersection($right), $right->intersection($left));
+    }
+
+    public function test_the_intersection_of_selections_of_no_row_selects_nothing(): void
+    {
+        static::assertEquals(new RowSelection(), RowSelection::all(0)->intersection(RowSelection::all(0)));
+    }
+
+    public function test_selections_of_other_row_counts_cannot_be_intersected(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Row selections of 10 and 9 rows cannot be combined');
+
+        RowSelection::all(10)->intersection(RowSelection::all(9));
+    }
+
+    public function test_the_union_selects_the_rows_either_selects(): void
+    {
+        $left = new RowSelection(new RowSelector(4, false), new RowSelector(4, true), new RowSelector(2, false));
+        $right = new RowSelection(new RowSelector(2, true), new RowSelector(3, false), new RowSelector(5, true));
+
+        static::assertEquals(
+            new RowSelection(new RowSelector(5, false), new RowSelector(3, true), new RowSelector(2, false)),
+            $left->union($right),
+        );
+        static::assertEquals($left->union($right), $right->union($left));
+        static::assertEquals(new RowSelection(), RowSelection::all(0)->union(RowSelection::none(0)));
+    }
+
+    public function test_the_difference_selects_the_rows_only_the_first_selects(): void
+    {
+        $left = new RowSelection(new RowSelector(4, false), new RowSelector(4, true), new RowSelector(2, false));
+        $right = new RowSelection(new RowSelector(2, true), new RowSelector(7, false), new RowSelector(1, true));
+
+        static::assertEquals(
+            new RowSelection(new RowSelector(2, false), new RowSelector(7, true), new RowSelector(1, false)),
+            $left->difference($right),
+        );
+        static::assertEquals(RowSelection::none(10), $left->difference($left));
+    }
+
+    public function test_a_mask_narrows_the_selected_rows_in_order(): void
+    {
+        $selection = new RowSelection(
+            new RowSelector(2, true),
+            new RowSelector(4, false),
+            new RowSelector(3, true),
+            new RowSelector(2, false),
+        );
+
+        static::assertEquals(
+            new RowSelection(
+                new RowSelector(3, true),
+                new RowSelector(2, false),
+                new RowSelector(4, true),
+                new RowSelector(1, false),
+                new RowSelector(1, true),
+            ),
+            $selection->masked([false, true, true, false, true, false]),
+        );
+        static::assertEquals($selection, $selection->masked([true, true, true, true, true, true]));
+        static::assertEquals(RowSelection::none(11), $selection->masked([false, false, false, false, false, false]));
+    }
+
+    public function test_the_head_selects_the_first_selected_rows(): void
+    {
+        $selection = new RowSelection(
+            new RowSelector(2, true),
+            new RowSelector(3, false),
+            new RowSelector(1, true),
+            new RowSelector(4, false),
+        );
+
+        static::assertEquals(
+            new RowSelection(
+                new RowSelector(2, true),
+                new RowSelector(3, false),
+                new RowSelector(1, true),
+                new RowSelector(1, false),
+                new RowSelector(3, true),
+            ),
+            $selection->head(4),
+        );
+        static::assertEquals($selection, $selection->head(7));
+        static::assertEquals($selection, $selection->head(9));
+        static::assertEquals(RowSelection::none(10), $selection->head(0));
+    }
+
+    public function test_a_mask_of_another_row_count_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A mask of 2 rows cannot narrow a selection of 3 rows');
+
+        RowSelection::window(5, 1, 3)->masked([true, false]);
+    }
+
+    public function test_selections_of_other_row_counts_cannot_be_united(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Row selections of 10 and 9 rows cannot be combined');
+
+        RowSelection::all(10)->union(RowSelection::all(9));
+    }
+
+    public function test_none_skips_every_row(): void
+    {
+        static::assertEquals(new RowSelection(new RowSelector(4, true)), RowSelection::none(4));
+        static::assertSame(4, RowSelection::none(4)->totalRows());
+        static::assertSame(0, RowSelection::none(4)->rowCount());
+    }
+
+    public function test_a_selection_contains_every_selection_of_a_subset_of_its_rows(): void
+    {
+        $selection = new RowSelection(new RowSelector(2, true), new RowSelector(5, false), new RowSelector(2, true));
+
+        static::assertTrue($selection->contains($selection));
+        static::assertTrue($selection->contains(RowSelection::none(9)));
+        static::assertTrue($selection->contains(RowSelection::window(9, 3, 2)));
+        static::assertFalse($selection->contains(RowSelection::window(9, 1, 2)));
+        static::assertFalse($selection->contains(RowSelection::all(9)));
+    }
+
+    public function test_the_row_count_is_the_selected_rows_and_selects_any_tells_whether_there_are_some(): void
+    {
+        $selection = new RowSelection(new RowSelector(2, true), new RowSelector(3, false), new RowSelector(4, true));
+
+        static::assertSame(3, $selection->rowCount());
+        static::assertSame(9, $selection->totalRows());
+        static::assertTrue($selection->selectsAny());
+        static::assertFalse(RowSelection::none(9)->selectsAny());
+        static::assertFalse(RowSelection::all(0)->selectsAny());
+    }
+
+    public function test_a_split_is_one_selection_per_part(): void
+    {
+        $selection = new RowSelection(new RowSelector(2, true), new RowSelector(3, false), new RowSelector(4, true));
+
+        static::assertEquals(
+            [
+                new RowSelection(new RowSelector(1, true)),
+                new RowSelection(new RowSelector(1, true), new RowSelector(2, false)),
+                new RowSelection(),
+                new RowSelection(new RowSelector(1, false), new RowSelector(4, true)),
+            ],
+            $selection->split([1, 3, 0, 5]),
+        );
+        static::assertEquals([new RowSelection()], RowSelection::all(0)->split([0]));
+        static::assertEquals([], RowSelection::all(0)->split([]));
+    }
+
+    /**
+     * @param list<int> $rowCounts
+     */
+    #[TestWith([[4, 4]])]
+    #[TestWith([[5, 5]])]
+    #[TestWith([[]])]
+    public function test_a_split_into_parts_of_another_row_count_is_refused(array $rowCounts): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A selection of 9 rows cannot be split into parts of');
+
+        RowSelection::all(9)->split($rowCounts);
+    }
+
+    public function test_a_slice_is_the_rows_from_an_offset_its_first_row_being_row_0(): void
+    {
+        $selection = new RowSelection(
+            new RowSelector(2, true),
+            new RowSelector(3, false),
+            new RowSelector(4, true),
+            new RowSelector(1, false),
+        );
+
+        static::assertEquals(
+            new RowSelection(new RowSelector(1, true), new RowSelector(2, false)),
+            $selection->slice(1, 3),
+        );
+        static::assertEquals(new RowSelection(new RowSelector(2, false)), $selection->slice(3, 2));
+        static::assertEquals(
+            new RowSelection(new RowSelector(1, false), new RowSelector(4, true), new RowSelector(1, false)),
+            $selection->slice(4, 6),
+        );
+        static::assertEquals(new RowSelection(), $selection->slice(10, 0));
+        static::assertEquals($selection, $selection->slice(0, 10));
+        static::assertEquals(new RowSelection(), RowSelection::all(0)->slice(0, 0));
+    }
+
+    #[TestWith([-1, 1])]
+    #[TestWith([0, -1])]
+    #[TestWith([8, 3])]
+    public function test_a_slice_outside_the_selection_is_refused(int $offset, int $rows): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('lie outside a selection of 10 rows');
+
+        RowSelection::all(10)->slice($offset, $rows);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/RowSelectorTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/RowSelectorTest.php
new file mode 100644
index 0000000000..23456859a0
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/RowSelectorTest.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Reader\RowSelector;
+use PHPUnit\Framework\TestCase;
+
+final class RowSelectorTest extends TestCase
+{
+    public function test_a_negative_row_count_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Row selector row count must be 0 or more, got -1');
+
+        new RowSelector(-1, false);
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/SelectedPagesTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/SelectedPagesTest.php
new file mode 100644
index 0000000000..ad1d3f68a0
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Reader/SelectedPagesTest.php
@@ -0,0 +1,212 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Reader;
+
+use Flow\Filesystem\Stream\MemorySourceStream;
+use Flow\Parquet\Binary\ByteOrder;
+use Flow\Parquet\Dremel\ColumnData\ReadFlatColumnValues;
+use Flow\Parquet\Engine\PhpParquetFileReader;
+use Flow\Parquet\Exception\RuntimeException;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Index\StreamIndexes;
+use Flow\Parquet\Reader\ColumnChunkReader;
+use Flow\Parquet\Reader\PageReader;
+use Flow\Parquet\Reader\RowSelection;
+use Flow\Parquet\Reader\SelectedPages;
+use Flow\Parquet\Tests\Context\MemoryParquetFile;
+use Flow\Parquet\Tests\Double\InMemoryIndexes;
+use Flow\Parquet\Tests\Double\ReadCountingSourceStream;
+use PHPUnit\Framework\TestCase;
+
+use function array_keys;
+use function array_map;
+use function iterator_to_array;
+
+final class SelectedPagesTest extends TestCase
+{
+    public function test_only_the_pages_holding_a_selected_row_are_yielded_with_their_rows(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footer = (new PhpParquetFileReader(
+            new MemorySourceStream($bytes),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        ))->footer();
+        $indexes = new StreamIndexes($footer, new MemorySourceStream($bytes));
+        $id = $footer->metadata()->schema()->getFlat('id');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+        $offsetIndex = $indexes->offsetIndex(0, $id) ?? static::fail('No offset index');
+
+        $pages = iterator_to_array((new SelectedPages(
+            new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+        ))->read(
+            $id,
+            $footer->metadata()->rowGroups()->all()[0],
+            0,
+            $stream,
+            RowSelection::window(12, 3, 2),
+            $indexes,
+            ['pages' => [], 'dictionary' => null],
+        ));
+
+        static::assertSame(
+            [2 => [[2, 3], 1], 4 => [[4, 5], 1]],
+            array_map(static fn(array $page): array => [
+                iterator_to_array($page[0]->rawValues(), false),
+                $page[1]->rowCount(),
+            ], $pages),
+        );
+        static::assertSame(
+            $offsetIndex->pages[1]->compressedPageSize + $offsetIndex->pages[2]->compressedPageSize,
+            $stream->bytes,
+        );
+    }
+
+    public function test_trimmed_pages_hold_only_the_selected_rows(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footer = (new PhpParquetFileReader(
+            new MemorySourceStream($bytes),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        ))->footer();
+        $stream = new MemorySourceStream($bytes);
+
+        static::assertSame(
+            [[3], [4]],
+            array_map(
+                static fn(ReadFlatColumnValues $page): array => iterator_to_array($page->rawValues(), false),
+                iterator_to_array((new SelectedPages(
+                    new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+                ))->trimmed(
+                    $footer->metadata()->schema()->getFlat('id'),
+                    $footer->metadata()->rowGroups()->all()[0],
+                    0,
+                    $stream,
+                    RowSelection::window(12, 3, 2),
+                    new StreamIndexes($footer, $stream),
+                    ['pages' => [], 'dictionary' => null],
+                ), false),
+            ),
+        );
+    }
+
+    public function test_a_decoded_page_is_served_and_only_the_other_selected_page_read(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footer = (new PhpParquetFileReader(
+            new MemorySourceStream($bytes),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        ))->footer();
+        $indexes = new StreamIndexes($footer, new MemorySourceStream($bytes));
+        $id = $footer->metadata()->schema()->getFlat('id');
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        static::assertSame(
+            [[50], [6]],
+            array_map(
+                static fn(ReadFlatColumnValues $page): array => iterator_to_array($page->rawValues(), false),
+                iterator_to_array((new SelectedPages(
+                    new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+                ))->trimmed(
+                    $id,
+                    $footer->metadata()->rowGroups()->all()[0],
+                    0,
+                    $stream,
+                    RowSelection::window(12, 5, 2),
+                    $indexes,
+                    ['pages' => [4 => ['values' => [40, 50], 'definitionLevels' => [1, 1]]], 'dictionary' => null],
+                ), false),
+            ),
+        );
+        static::assertSame(
+            ($indexes->offsetIndex(0, $id) ?? static::fail('No offset index'))->pages[3]->compressedPageSize,
+            $stream->bytes,
+        );
+    }
+
+    public function test_when_every_selected_page_is_decoded_nothing_is_read_and_the_given_dictionary_returned(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $footer = (new PhpParquetFileReader(
+            new MemorySourceStream($bytes),
+            ByteOrder::LITTLE_ENDIAN,
+            new Options(),
+        ))->footer();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        $pages = (new SelectedPages(
+            new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+        ))->read(
+            $footer->metadata()->schema()->getFlat('word'),
+            $footer->metadata()->rowGroups()->all()[0],
+            0,
+            $stream,
+            RowSelection::window(12, 2, 2),
+            new StreamIndexes($footer, new MemorySourceStream($bytes)),
+            ['pages' => [2 => ['values' => ['a', 'b'], 'definitionLevels' => [1, 1]]], 'dictionary' => null],
+        );
+
+        static::assertSame([2], array_keys(iterator_to_array($pages)));
+        static::assertNull($pages->getReturn());
+        static::assertSame(0, $stream->reads);
+    }
+
+    public function test_without_an_offset_index_the_decoded_pages_are_served_alone(): void
+    {
+        $bytes = MemoryParquetFile::pagedColumns();
+        $metadata = (new PhpParquetFileReader(new MemorySourceStream($bytes), ByteOrder::LITTLE_ENDIAN, new Options()))
+            ->footer()
+            ->metadata();
+        $stream = new ReadCountingSourceStream(new MemorySourceStream($bytes));
+
+        static::assertSame(
+            [[40, 50], [60]],
+            array_map(
+                static fn(ReadFlatColumnValues $page): array => iterator_to_array($page->rawValues(), false),
+                iterator_to_array((new SelectedPages(
+                    new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+                ))->trimmed(
+                    $metadata->schema()->getFlat('id'),
+                    $metadata->rowGroups()->all()[0],
+                    0,
+                    $stream,
+                    RowSelection::window(12, 4, 3),
+                    new InMemoryIndexes(),
+                    [
+                        'pages' => [
+                            4 => ['values' => [40, 50], 'definitionLevels' => [1, 1]],
+                            6 => ['values' => [60, 70], 'definitionLevels' => [1, 1]],
+                        ],
+                        'dictionary' => null,
+                    ],
+                ), false),
+            ),
+        );
+        static::assertSame(0, $stream->reads);
+    }
+
+    public function test_a_row_group_decoding_more_rows_than_its_selection_is_refused(): void
+    {
+        $stream = new MemorySourceStream(MemoryParquetFile::threeRowGroups());
+        $metadata = (new PhpParquetFileReader($stream, ByteOrder::LITTLE_ENDIAN, new Options()))->footer()->metadata();
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Row group 0 decodes more than the 1 rows its metadata declares');
+
+        iterator_to_array((new SelectedPages(
+            new ColumnChunkReader(new PageReader(ByteOrder::LITTLE_ENDIAN, new Options()), new Options()),
+        ))->read(
+            $metadata->schema()->getFlat('id'),
+            $metadata->rowGroups()->all()[0],
+            0,
+            $stream,
+            RowSelection::all(1),
+            new InMemoryIndexes(),
+            ['pages' => [], 'dictionary' => null],
+        ));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Thrift/CompactProtocolTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Thrift/CompactProtocolTest.php
index 7939da0c99..a120121ad2 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Thrift/CompactProtocolTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Thrift/CompactProtocolTest.php
@@ -569,8 +569,8 @@ public function test_write_read_bool_in_container(): void
         $readProtocol->readBool($bool2);
         $readProtocol->readCollectionEnd();
 
-        static::assertSame(1, $bool1);
-        static::assertSame(0, $bool2);
+        static::assertTrue($bool1);
+        static::assertFalse($bool2);
     }
 
     public function test_write_read_bool_throws_exception_in_invalid_state(): void
@@ -1092,4 +1092,33 @@ public function test_zigzag_encode_decode(int $value, int $bits, int $expectedZi
         $decoded = $protocol->fromZigZag($zigzag);
         static::assertSame($value, $decoded);
     }
+
+    public function test_a_bool_list_element_is_true_only_for_one(): void
+    {
+        $protocol = new CompactProtocol(new MemoryBuffer("\x31\x01\x02\x00"));
+        $type = 0;
+        $size = 0;
+        $protocol->readListBegin($type, $size);
+        $values = [];
+
+        for ($i = 0; $i < $size; $i++) {
+            $value = false;
+            $protocol->readBool($value);
+            $values[] = $value;
+        }
+
+        static::assertSame(TType::BOOL, $type);
+        static::assertSame([true, false, false], $values);
+    }
+
+    public function test_a_false_bool_list_element_is_written_as_two(): void
+    {
+        $protocol = new CompactProtocol($buffer = new MemoryBuffer());
+        $protocol->writeListBegin(TType::BOOL, 2);
+        $protocol->writeBool(true);
+        $protocol->writeBool(false);
+        $protocol->writeListEnd();
+
+        static::assertSame("\x21\x01\x02", $buffer->data());
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php
index ff68dc6255..5d2e82764b 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/DeltaBinaryPackedColumnChunkBuilderTest.php
@@ -8,15 +8,23 @@
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\Writer\ColumnChunkBuilder\DeltaBinaryPackedColumnChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkContainer;
+use Flow\Parquet\Writer\StatisticsOptions;
 use Generator;
 use InvalidArgumentException;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
+use function array_map;
+use function pack;
+use function strlen;
+
 final class DeltaBinaryPackedColumnChunkBuilderTest extends TestCase
 {
     public static function compression_types_provider(): Generator
@@ -54,6 +62,7 @@ public function test_constructor_rejects_unsupported_types(): void
             new FlatColumn('test_col', PhysicalType::FLOAT),
             new Options(),
             Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions(new Options()),
         );
     }
 
@@ -61,7 +70,12 @@ public function test_empty_builder_properties(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('test_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertSame($column, $builder->column());
         static::assertFalse($builder->isFull());
@@ -73,7 +87,12 @@ public function test_flush_cleans_up_builder_state(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, $compression);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [42, 84]));
 
@@ -96,7 +115,12 @@ public function test_flush_empty_builder(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('test_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $containers = $builder->flush(0);
 
@@ -109,7 +133,12 @@ public function test_flush_with_data(): void
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('test_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $values = [1, 2, 3, 4, 5];
 
@@ -130,7 +159,12 @@ public function test_is_full_calculation_for_int32(): void
         $options = (new Options())->set(Option::PAGE_SIZE_BYTES, 100)->set(Option::WRITER_VERSION, 2);
 
         $column = new FlatColumn('test_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 30; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$i]));
@@ -144,7 +178,12 @@ public function test_is_full_calculation_for_int64(): void
         $options = (new Options())->set(Option::PAGE_SIZE_BYTES, 100)->set(Option::WRITER_VERSION, 2);
 
         $column = new FlatColumn('test_col', PhysicalType::INT64);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 15; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$i]));
@@ -158,7 +197,12 @@ public function test_supports_different_compression_types(Compressions $compress
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('test_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, $compression);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertSame($column, $builder->column());
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
@@ -170,7 +214,12 @@ public function test_supports_different_writer_versions(int $version): void
         $options = (new Options())->set(Option::WRITER_VERSION, $version);
 
         $column = new FlatColumn('test_col', PhysicalType::INT32);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertSame($column, $builder->column());
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
@@ -181,9 +230,41 @@ public function test_supports_integer_types(PhysicalType $type, int $value): voi
     {
         $options = (new Options())->set(Option::WRITER_VERSION, 2);
         $column = new FlatColumn('test_col', $type);
-        $builder = new DeltaBinaryPackedColumnChunkBuilder($column, $options, Compressions::UNCOMPRESSED);
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            $options,
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertSame($column, $builder->column());
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
     }
+
+    public function test_each_page_gets_a_column_index_entry_and_an_offset_index_location(): void
+    {
+        $column = FlatColumn::int64('id');
+        $builder = new DeltaBinaryPackedColumnChunkBuilder(
+            $column,
+            new Options(),
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions(new Options()),
+        );
+        $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [1, 2]));
+        $builder->closePage();
+        $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
+        $container = $builder->flush(4)[0];
+        $last = $container->offsetIndex->pages[1];
+
+        static::assertEquals(
+            new ColumnIndex([false, true], [pack('P', 1), ''], [pack('P', 2), ''], BoundaryOrder::ASCENDING, [0, 1]),
+            $container->columnIndex,
+        );
+        static::assertSame(
+            [0, 2],
+            array_map(static fn(PageLocation $page): int => $page->firstRowIndex, $container->offsetIndex->pages),
+        );
+        static::assertSame($container->columnChunk->dataPageOffset(), $container->offsetIndex->pages[0]->offset);
+        static::assertSame(4 + strlen($container->binaryBuffer), $last->offset + $last->compressedPageSize);
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/NestedColumnChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/NestedColumnChunkBuilderTest.php
index 4da742c639..75c4592660 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/NestedColumnChunkBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/NestedColumnChunkBuilderTest.php
@@ -15,6 +15,7 @@
 use Flow\Parquet\Writer\ColumnChunkBuilder\NestedColumnChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkBuilder\PlainFlatColumnChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkContainer;
+use Flow\Parquet\Writer\StatisticsOptions;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
@@ -61,7 +62,12 @@ public function test_add_multiple_rows(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         for ($i = 0; $i < 5; $i++) {
@@ -81,9 +87,24 @@ public function test_add_row_finds_correct_child_builder_by_flat_path(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
-        $childBuilder3 = new PlainFlatColumnChunkBuilder($childColumn3, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder3 = new PlainFlatColumnChunkBuilder(
+            $childColumn3,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2, $childBuilder3]);
 
         $childBuilder2->addColumn(new WriteFlatColumnValues($childColumn2, [0], [1], ['middle_child']));
@@ -98,7 +119,12 @@ public function test_add_row_with_empty_data(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [], [], []));
@@ -115,8 +141,18 @@ public function test_add_row_with_multiple_children_data(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -133,7 +169,12 @@ public function test_add_row_with_null_values(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [0], []));
@@ -150,8 +191,18 @@ public function test_add_row_with_partial_child_data(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -167,7 +218,12 @@ public function test_add_row_with_single_child_data(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [1], [42]));
@@ -195,8 +251,18 @@ public function test_close_page_with_multiple_children(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -215,7 +281,12 @@ public function test_close_page_with_single_child(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [1], [42]));
@@ -233,7 +304,12 @@ public function test_column_returns_correct_nested_column(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $result = $builder->column();
@@ -249,7 +325,12 @@ public function test_constructor_initializes_correctly(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $childrenBuilders = [$childBuilder];
 
         $builder = new NestedColumnChunkBuilder($nestedColumn, $childrenBuilders);
@@ -273,7 +354,12 @@ public function test_constructor_with_different_nested_structures(array $childre
         $childrenBuilders = [];
 
         foreach ($children as $child) {
-            $childrenBuilders[] = new PlainFlatColumnChunkBuilder($child, $options, $compression);
+            $childrenBuilders[] = new PlainFlatColumnChunkBuilder(
+                $child,
+                $options,
+                $compression,
+                StatisticsOptions::fromOptions($options),
+            );
         }
 
         $builder = new NestedColumnChunkBuilder($nestedColumn, $childrenBuilders);
@@ -304,8 +390,18 @@ public function test_edge_case_mixed_null_and_non_null_across_children(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -327,8 +423,18 @@ public function test_edge_case_no_matching_flat_path(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -348,7 +454,12 @@ public function test_flush_automatically_closes_pages_when_data_exists(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [1], [42]));
@@ -370,9 +481,24 @@ public function test_flush_calculates_correct_file_offsets(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
-        $childBuilder3 = new PlainFlatColumnChunkBuilder($childColumn3, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder3 = new PlainFlatColumnChunkBuilder(
+            $childColumn3,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2, $childBuilder3]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -406,7 +532,12 @@ public function test_flush_cleans_up_child_builder_state(): void
         $nestedColumn = NestedColumn::create('nested', [$childColumn]);
         $options = new Options();
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0, 0], [1, 1], [42, 84]));
@@ -433,7 +564,12 @@ public function test_flush_with_different_file_offsets(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $offsets = [0, 100, 1000, 50000];
@@ -466,8 +602,18 @@ public function test_flush_with_multiple_children(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -490,7 +636,12 @@ public function test_flush_with_single_child(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [1], [42]));
@@ -510,7 +661,12 @@ public function test_is_full_initially_false(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         static::assertFalse($builder->isFull());
@@ -524,8 +680,18 @@ public function test_is_full_returns_false_when_no_child_is_full(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         static::assertFalse($builder->isFull());
@@ -539,7 +705,12 @@ public function test_is_full_returns_true_when_any_child_is_full(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $mockFullChildBuilder = $this->createStub(ColumnChunkBuilder::class);
         $mockFullChildBuilder->method('isFull')->willReturn(true);
@@ -565,7 +736,12 @@ public function test_multiple_close_page_calls(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [1], [42]));
@@ -584,7 +760,12 @@ public function test_uncompressed_size_initially_zero(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         static::assertSame(0, $builder->uncompressedSize());
@@ -598,8 +779,18 @@ public function test_uncompressed_size_sums_children_sizes(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         $childBuilder1->addColumn(new WriteFlatColumnValues($childColumn1, [0], [1], [42]));
@@ -649,8 +840,18 @@ public function test_workflow_complete_add_close_flush_cycle(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder1 = new PlainFlatColumnChunkBuilder($childColumn1, $options, $compression);
-        $childBuilder2 = new PlainFlatColumnChunkBuilder($childColumn2, $options, $compression);
+        $childBuilder1 = new PlainFlatColumnChunkBuilder(
+            $childColumn1,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
+        $childBuilder2 = new PlainFlatColumnChunkBuilder(
+            $childColumn2,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder1, $childBuilder2]);
 
         for ($i = 0; $i < 3; $i++) {
@@ -676,7 +877,12 @@ public function test_workflow_multiple_cycles(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         for ($cycle = 0; $cycle < 3; $cycle++) {
@@ -699,7 +905,12 @@ public function test_workflow_with_different_compressions(Compressions $compress
         $nestedColumn = NestedColumn::create('nested', [$childColumn]);
         $options = new Options();
 
-        $childBuilder = new PlainFlatColumnChunkBuilder($childColumn, $options, $compression);
+        $childBuilder = new PlainFlatColumnChunkBuilder(
+            $childColumn,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
         $builder = new NestedColumnChunkBuilder($nestedColumn, [$childBuilder]);
 
         $childBuilder->addColumn(new WriteFlatColumnValues($childColumn, [0], [1], [42]));
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilderTest.php
index f58e38cfee..ab8c8c2be4 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/PlainFlatColumnChunkBuilderTest.php
@@ -8,16 +8,24 @@
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\Writer\ColumnChunkBuilder\PlainFlatColumnChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkContainer;
+use Flow\Parquet\Writer\StatisticsOptions;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use RuntimeException;
 
+use function array_map;
+use function pack;
+use function strlen;
+
 final class PlainFlatColumnChunkBuilderTest extends TestCase
 {
     public static function compression_types_provider(): Generator
@@ -55,7 +63,12 @@ public function test_add_multiple_rows(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 5; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$i * 10]));
@@ -70,7 +83,12 @@ public function test_add_row_with_boolean_values(): void
         $column = new FlatColumn('bool_col', PhysicalType::BOOLEAN);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [true, false]));
 
@@ -83,7 +101,12 @@ public function test_add_row_with_empty_data(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [], [], []));
 
@@ -96,7 +119,12 @@ public function test_add_row_with_extreme_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT64);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [PHP_INT_MAX, PHP_INT_MIN]));
 
@@ -112,7 +140,12 @@ public function test_add_row_with_multiple_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [1, 1, 0], [42, 100]));
 
@@ -125,7 +158,12 @@ public function test_add_row_with_null_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
 
@@ -138,7 +176,12 @@ public function test_add_row_with_repetition_levels(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 1], [1, 1], [42, 100]));
 
@@ -154,7 +197,12 @@ public function test_add_row_with_single_value(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -167,7 +215,12 @@ public function test_add_row_with_string_values(): void
         $column = new FlatColumn('str_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], ['hello', 'world']));
 
@@ -180,7 +233,12 @@ public function test_add_row_with_very_large_definition_levels(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [255], [42]));
 
@@ -196,7 +254,12 @@ public function test_close_page_resets_internal_state(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -212,7 +275,12 @@ public function test_close_page_with_data(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -229,7 +297,12 @@ public function test_close_page_with_different_writer_versions(int $writerVersio
         $options = new Options();
         $options->set(Option::WRITER_VERSION, $writerVersion);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -243,7 +316,12 @@ public function test_close_page_with_empty_data(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->closePage();
 
@@ -257,7 +335,12 @@ public function test_close_page_with_unsupported_writer_version_throws_exception
         $options = new Options();
         $options->set(Option::WRITER_VERSION, 3);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -274,7 +357,12 @@ public function test_column_returns_correct_column(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $result = $builder->column();
 
@@ -287,7 +375,12 @@ public function test_constructor_initializes_correctly(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
         static::assertSame($column, $builder->column());
@@ -301,7 +394,12 @@ public function test_constructor_with_boolean_column_uses_boolean_storage(): voi
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
         static::assertSame($column, $builder->column());
@@ -313,7 +411,12 @@ public function test_constructor_with_byte_array_logical_type(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
         static::assertSame($column, $builder->column());
@@ -325,7 +428,12 @@ public function test_constructor_with_different_compressions(Compressions $compr
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
 
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -337,7 +445,12 @@ public function test_constructor_with_different_physical_types(PhysicalType $phy
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
         static::assertSame($column, $builder->column());
@@ -348,7 +461,12 @@ public function test_edge_case_boolean_false_value(): void
         $column = new FlatColumn('bool_col', PhysicalType::BOOLEAN);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [false]));
 
@@ -364,7 +482,12 @@ public function test_edge_case_empty_string_value(): void
         $column = new FlatColumn('str_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['']));
 
@@ -380,7 +503,12 @@ public function test_edge_case_large_string_value(): void
         $column = new FlatColumn('str_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $largeString = str_repeat('x', 10000);
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$largeString]));
@@ -397,7 +525,12 @@ public function test_edge_case_zero_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [0]));
 
@@ -413,7 +546,12 @@ public function test_flush_automatically_closes_page_when_data_exists(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -430,7 +568,12 @@ public function test_flush_cleans_up_builder_state(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [42, 84]));
 
@@ -454,7 +597,12 @@ public function test_flush_preserves_column_chunk_metadata(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::GZIP;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -472,7 +620,12 @@ public function test_flush_with_data(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -490,7 +643,12 @@ public function test_flush_with_different_file_offsets(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $offsets = [0, 100, 1000, 50000];
 
@@ -508,7 +666,12 @@ public function test_flush_with_empty_data(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $containers = $builder->flush(0);
 
@@ -523,7 +686,12 @@ public function test_flush_with_negative_file_offset(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $containers = $builder->flush(-100);
 
@@ -537,7 +705,12 @@ public function test_is_full_initially_false(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertFalse($builder->isFull());
     }
@@ -549,7 +722,12 @@ public function test_is_full_respects_page_size_option(int $pageSize): void
         $options = new Options();
         $options->set(Option::PAGE_SIZE_BYTES, $pageSize);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertFalse($builder->isFull());
 
@@ -570,7 +748,12 @@ public function test_is_full_with_zero_page_size(): void
         $options = new Options();
         $options->set(Option::PAGE_SIZE_BYTES, 0);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -582,7 +765,12 @@ public function test_mixed_null_and_non_null_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [1, 0, 1], [42, 100]));
 
@@ -598,7 +786,12 @@ public function test_multiple_close_page_calls(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -614,7 +807,12 @@ public function test_multiple_flush_calls_maintain_consistency(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $containers1 = $builder->flush(0);
         $containers2 = $builder->flush(100);
@@ -634,7 +832,12 @@ public function test_statistics_are_generated(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [1, 1, 1], [10, 50, 30]));
 
@@ -649,7 +852,12 @@ public function test_statistics_track_null_count_for_all_null_chunk(): void
         $column = FlatColumn::string('all_null');
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [0, 0, 0], []));
 
@@ -666,7 +874,12 @@ public function test_statistics_track_null_count_for_mixed_chunk(): void
         $column = FlatColumn::string('mixed');
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [1, 0, 1], ['x', 'z']));
 
@@ -674,8 +887,10 @@ public function test_statistics_track_null_count_for_mixed_chunk(): void
 
         static::assertNotNull($statistics);
         static::assertSame(1, $statistics->nullCount());
-        static::assertSame('x', $statistics->min($column));
-        static::assertSame('z', $statistics->max($column));
+        static::assertSame('x', $statistics->minValue($column));
+        static::assertSame('z', $statistics->maxValue($column));
+        static::assertNull($statistics->min($column));
+        static::assertNull($statistics->max($column));
     }
 
     public function test_uncompressed_size_accumulates_multiple_pages(): void
@@ -683,7 +898,12 @@ public function test_uncompressed_size_accumulates_multiple_pages(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $sizes = [];
 
@@ -703,7 +923,12 @@ public function test_uncompressed_size_increases_with_pages(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $initialSize = $builder->uncompressedSize();
 
@@ -720,7 +945,12 @@ public function test_uncompressed_size_initially_zero(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertSame(0, $builder->uncompressedSize());
     }
@@ -730,7 +960,12 @@ public function test_uncompressed_size_with_large_data(): void
         $column = new FlatColumn('str_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $largeString = str_repeat('A', 50000);
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$largeString]));
@@ -746,7 +981,12 @@ public function test_workflow_add_close_flush(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [42]));
 
@@ -764,7 +1004,12 @@ public function test_workflow_multiple_add_single_close_flush(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 5; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$i * 10]));
@@ -785,7 +1030,12 @@ public function test_workflow_multiple_cycles(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($cycle = 0; $cycle < 3; $cycle++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$cycle * 100]));
@@ -805,7 +1055,12 @@ public function test_workflow_with_all_null_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new PlainFlatColumnChunkBuilder($column, $options, $compression);
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 5; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
@@ -817,4 +1072,31 @@ public function test_workflow_with_all_null_values(): void
         static::assertCount(1, $containers);
         static::assertSame(5, $containers[0]->columnChunk->valuesCount());
     }
+
+    public function test_each_page_gets_a_column_index_entry_and_an_offset_index_location(): void
+    {
+        $column = FlatColumn::int64('id');
+        $builder = new PlainFlatColumnChunkBuilder(
+            $column,
+            new Options(),
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions(new Options()),
+        );
+        $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [1, 2]));
+        $builder->closePage();
+        $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
+        $container = $builder->flush(4)[0];
+        $last = $container->offsetIndex->pages[1];
+
+        static::assertEquals(
+            new ColumnIndex([false, true], [pack('P', 1), ''], [pack('P', 2), ''], BoundaryOrder::ASCENDING, [0, 1]),
+            $container->columnIndex,
+        );
+        static::assertSame(
+            [0, 2],
+            array_map(static fn(PageLocation $page): int => $page->firstRowIndex, $container->offsetIndex->pages),
+        );
+        static::assertSame($container->columnChunk->dataPageOffset(), $container->offsetIndex->pages[0]->offset);
+        static::assertSame(4 + strlen($container->binaryBuffer), $last->offset + $last->compressedPageSize);
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php
index 8556086876..a20569cf6a 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilder/RLEDictionaryChunkBuilderTest.php
@@ -8,21 +8,26 @@
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
-use Flow\Parquet\ParquetFile\Data\Codec;
 use Flow\Parquet\ParquetFile\Encodings;
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
 use Flow\Parquet\Writer\ColumnChunkBuilder\RLEDictionaryChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkContainer;
+use Flow\Parquet\Writer\StatisticsOptions;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
-use ReflectionClass;
 use RuntimeException;
 
+use function array_map;
 use function is_object;
 use function is_scalar;
+use function pack;
+use function strlen;
 
 final class RLEDictionaryChunkBuilderTest extends TestCase
 {
@@ -89,7 +94,12 @@ public function test_add_multiple_rows(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 5; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ["value_{$i}"]));
@@ -108,7 +118,12 @@ public function test_add_row_with_dictionary_data(array $values, string $descrip
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $repLevels = [];
         $defLevels = [];
@@ -140,7 +155,12 @@ public function test_add_row_with_empty_data(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [], [], []));
 
@@ -153,7 +173,12 @@ public function test_add_row_with_null_values(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
 
@@ -166,7 +191,12 @@ public function test_add_row_with_repeated_values(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(
             new WriteFlatColumnValues(
@@ -186,7 +216,12 @@ public function test_add_row_with_single_value(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['hello']));
 
@@ -194,23 +229,19 @@ public function test_add_row_with_single_value(): void
         static::assertGreaterThanOrEqual(0, $builder->uncompressedSize());
     }
 
-    public function test_build_dictionary_page_without_dictionary_throws_exception(): void
+    public function test_a_chunk_without_values_writes_no_dictionary_page(): void
     {
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
-        $options = new Options();
-        $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
-
-        $builder->addColumn(new WriteFlatColumnValues($column, [], [], []));
-
-        $reflectionClass = new ReflectionClass($builder);
-        $buildDictionaryPageMethod = $reflectionClass->getMethod('buildDictionaryPage');
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            new Options(),
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions(new Options()),
+        );
 
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Cannot build dictionary page without dictionary');
+        $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
 
-        $codec = new Codec($options);
-        $buildDictionaryPageMethod->invoke($builder, $codec, $compression);
+        static::assertNull($builder->flush(4)[0]->columnChunk->dictionaryPageOffset());
     }
 
     public function test_close_page_resets_internal_state(): void
@@ -218,7 +249,12 @@ public function test_close_page_resets_internal_state(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -234,7 +270,12 @@ public function test_close_page_with_data_builds_dictionary(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(
             new WriteFlatColumnValues($column, [0, 0, 0, 0], [1, 1, 1, 1], ['apple', 'banana', 'apple', 'cherry']),
@@ -253,7 +294,12 @@ public function test_close_page_with_different_writer_versions(int $writerVersio
         $options = new Options();
         $options->set(Option::WRITER_VERSION, $writerVersion);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -267,7 +313,12 @@ public function test_close_page_with_empty_data(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->closePage();
 
@@ -281,7 +332,12 @@ public function test_close_page_with_unsupported_writer_version_throws_exception
         $options = new Options();
         $options->set(Option::WRITER_VERSION, 3);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -298,7 +354,12 @@ public function test_column_returns_correct_column(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $result = $builder->column();
 
@@ -311,7 +372,12 @@ public function test_constructor_initializes_correctly(): void
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(RLEDictionaryChunkBuilder::class, $builder);
         static::assertSame($column, $builder->column());
@@ -325,7 +391,12 @@ public function test_constructor_with_different_compressions(Compressions $compr
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
 
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(RLEDictionaryChunkBuilder::class, $builder);
     }
@@ -342,7 +413,12 @@ public function test_constructor_with_different_physical_types(
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
 
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(RLEDictionaryChunkBuilder::class, $builder);
         static::assertSame($column, $builder->column());
@@ -353,7 +429,12 @@ public function test_dictionary_compression_efficiency(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $repeatedValues = ['apple', 'banana', 'cherry'];
         $repLevels = [];
@@ -383,7 +464,12 @@ public function test_different_compressions_work_correctly(Compressions $compres
     {
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -399,7 +485,12 @@ public function test_edge_case_boolean_false_value(): void
         $column = new FlatColumn('bool_col', PhysicalType::BOOLEAN);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [false]));
 
@@ -415,7 +506,12 @@ public function test_edge_case_empty_string_value(): void
         $column = new FlatColumn('str_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['']));
 
@@ -431,7 +527,12 @@ public function test_edge_case_large_string_value(): void
         $column = new FlatColumn('str_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $largeString = str_repeat('x', 10000);
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [$largeString]));
@@ -448,7 +549,12 @@ public function test_edge_case_zero_values(): void
         $column = new FlatColumn('test_col', PhysicalType::INT32);
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], [0]));
 
@@ -464,7 +570,12 @@ public function test_flush_automatically_closes_page_when_data_exists(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -481,7 +592,12 @@ public function test_flush_cleans_up_builder_state(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], ['hello', 'world']));
 
@@ -505,7 +621,12 @@ public function test_flush_preserves_column_chunk_metadata(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::GZIP;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -523,7 +644,12 @@ public function test_flush_with_data(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -541,7 +667,12 @@ public function test_flush_with_dictionary_includes_dictionary_page(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(
             new WriteFlatColumnValues($column, [0, 0, 0, 0], [1, 1, 1, 1], ['apple', 'banana', 'apple', 'cherry']),
@@ -563,7 +694,12 @@ public function test_flush_with_different_file_offsets(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $offsets = [0, 100, 1000, 50000];
 
@@ -581,7 +717,12 @@ public function test_flush_with_empty_data(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $containers = $builder->flush(0);
 
@@ -596,7 +737,12 @@ public function test_is_full_initially_false(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertFalse($builder->isFull());
     }
@@ -608,7 +754,12 @@ public function test_is_full_respects_page_size_option(int $pageSize): void
         $options = new Options();
         $options->set(Option::PAGE_SIZE_BYTES, $pageSize);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertFalse($builder->isFull());
 
@@ -629,7 +780,12 @@ public function test_is_full_uses_approximate_calculation(): void
         $options = new Options();
         $options->set(Option::PAGE_SIZE_BYTES, 100);
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 30; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ["value_{$i}"]));
@@ -643,7 +799,12 @@ public function test_mixed_null_and_non_null_values(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [1, 0, 1], ['hello', 'world']));
 
@@ -659,7 +820,12 @@ public function test_multiple_close_page_calls(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -675,7 +841,12 @@ public function test_statistics_are_generated(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0, 0, 0], [1, 1, 1], ['apple', 'zebra', 'banana']));
 
@@ -690,7 +861,12 @@ public function test_uncompressed_size_accumulates_multiple_pages(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $sizes = [];
 
@@ -710,7 +886,12 @@ public function test_uncompressed_size_increases_with_pages(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $initialSize = $builder->uncompressedSize();
 
@@ -727,7 +908,12 @@ public function test_uncompressed_size_initially_zero(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertSame(0, $builder->uncompressedSize());
     }
@@ -737,7 +923,12 @@ public function test_workflow_add_close_flush(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ['test']));
 
@@ -755,7 +946,12 @@ public function test_workflow_multiple_add_single_close_flush(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($i = 0; $i < 5; $i++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ["value_{$i}"]));
@@ -776,7 +972,12 @@ public function test_workflow_multiple_cycles(): void
         $column = new FlatColumn('test_col', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::string());
         $options = new Options();
         $compression = Compressions::UNCOMPRESSED;
-        $builder = new RLEDictionaryChunkBuilder($column, $options, $compression);
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            $options,
+            $compression,
+            StatisticsOptions::fromOptions($options),
+        );
 
         for ($cycle = 0; $cycle < 3; $cycle++) {
             $builder->addColumn(new WriteFlatColumnValues($column, [0], [1], ["cycle_{$cycle}"]));
@@ -790,4 +991,31 @@ public function test_workflow_multiple_cycles(): void
         static::assertInstanceOf(ColumnChunkContainer::class, $containers[0]);
         static::assertSame(3, $containers[0]->columnChunk->valuesCount());
     }
+
+    public function test_each_page_gets_a_column_index_entry_and_an_offset_index_location(): void
+    {
+        $column = FlatColumn::int64('id');
+        $builder = new RLEDictionaryChunkBuilder(
+            $column,
+            new Options(),
+            Compressions::UNCOMPRESSED,
+            StatisticsOptions::fromOptions(new Options()),
+        );
+        $builder->addColumn(new WriteFlatColumnValues($column, [0, 0], [1, 1], [1, 2]));
+        $builder->closePage();
+        $builder->addColumn(new WriteFlatColumnValues($column, [0], [0], []));
+        $container = $builder->flush(4)[0];
+        $last = $container->offsetIndex->pages[1];
+
+        static::assertEquals(
+            new ColumnIndex([false, true], [pack('P', 1), ''], [pack('P', 2), ''], BoundaryOrder::ASCENDING, [0, 1]),
+            $container->columnIndex,
+        );
+        static::assertSame(
+            [0, 2],
+            array_map(static fn(PageLocation $page): int => $page->firstRowIndex, $container->offsetIndex->pages),
+        );
+        static::assertSame($container->columnChunk->dataPageOffset(), $container->offsetIndex->pages[0]->offset);
+        static::assertSame(4 + strlen($container->binaryBuffer), $last->offset + $last->compressedPageSize);
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilderFactoryTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilderFactoryTest.php
index 57b25c152f..7c0de2e393 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilderFactoryTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuilderFactoryTest.php
@@ -16,6 +16,7 @@
 use Flow\Parquet\Writer\ColumnChunkBuilder\PlainFlatColumnChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkBuilder\RLEDictionaryChunkBuilder;
 use Flow\Parquet\Writer\ColumnChunkBuilderFactory;
+use Flow\Parquet\Writer\StatisticsOptions;
 use PHPUnit\Framework\TestCase;
 
 final class ColumnChunkBuilderFactoryTest extends TestCase
@@ -28,7 +29,12 @@ public function test_create_builder_custom_encoding_overrides_automatic_selectio
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -39,7 +45,12 @@ public function test_create_builder_for_int32_column_with_plain_encoding(): void
         $options = Options::default();
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -50,7 +61,12 @@ public function test_create_builder_for_int32_column_with_writer_version_2(): vo
         $options = Options::default()->set(Option::WRITER_VERSION, 2);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
     }
@@ -61,7 +77,12 @@ public function test_create_builder_for_int64_column_with_writer_version_2(): vo
         $options = Options::default()->set(Option::WRITER_VERSION, 2);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
     }
@@ -72,7 +93,12 @@ public function test_create_builder_for_string_column(): void
         $options = Options::default();
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -85,7 +111,12 @@ public function test_create_builder_with_custom_delta_binary_packed_encoding():
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
     }
@@ -98,7 +129,12 @@ public function test_create_builder_with_custom_plain_encoding(): void
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -111,7 +147,12 @@ public function test_create_builder_with_custom_rle_dictionary_encoding(): void
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(RLEDictionaryChunkBuilder::class, $builder);
     }
@@ -125,7 +166,12 @@ public function test_create_builder_with_flat_path_encoding(): void
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(DeltaBinaryPackedColumnChunkBuilder::class, $builder);
     }
@@ -138,7 +184,12 @@ public function test_create_builder_with_rle_dictionary_encoding(): void
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(RLEDictionaryChunkBuilder::class, $builder);
     }
@@ -149,7 +200,12 @@ public function test_empty_columns_encodings_option(): void
         $options = Options::default()->set(Option::COLUMNS_ENCODINGS, []);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -162,7 +218,12 @@ public function test_fallback_to_plain_when_no_custom_encoding_specified(): void
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
     }
@@ -180,7 +241,12 @@ public function test_invalid_delta_binary_packed_encoding_for_string_column_thro
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
     }
 
     public function test_invalid_rle_dictionary_encoding_for_fixed_len_byte_array_throws_exception(): void
@@ -196,7 +262,12 @@ public function test_invalid_rle_dictionary_encoding_for_fixed_len_byte_array_th
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
     }
 
     public function test_non_enum_encoding_value_is_ignored(): void
@@ -207,7 +278,12 @@ public function test_non_enum_encoding_value_is_ignored(): void
         ]);
         $compressions = Compressions::UNCOMPRESSED;
 
-        $builder = ColumnChunkBuilderFactory::createBuilder($column, $options, $compressions);
+        $builder = ColumnChunkBuilderFactory::createBuilder(
+            $column,
+            $options,
+            $compressions,
+            StatisticsOptions::fromOptions($options),
+        );
 
         // Should fallback to default behavior since non-enum is ignored
         static::assertInstanceOf(PlainFlatColumnChunkBuilder::class, $builder);
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuildersTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuildersTest.php
index 6a8763b5dc..3f6b8e165f 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuildersTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/ColumnChunkBuildersTest.php
@@ -4,7 +4,11 @@
 
 namespace Flow\Parquet\Tests\Unit\Writer;
 
+use Flow\Parquet\BloomFilter\BloomFilterOptions;
+use Flow\Parquet\BloomFilter\BloomHash;
+use Flow\Parquet\BloomFilter\Sbbf;
 use Flow\Parquet\Dremel\ColumnData\WriteFlatColumnValues;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
@@ -26,8 +30,82 @@
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 
+use function str_repeat;
+
 final class ColumnChunkBuildersTest extends TestCase
 {
+    public function test_bloom_filters_hold_the_non_null_values_of_the_columns_asked_by_flat_path(): void
+    {
+        $city = FlatColumn::string('city');
+        $id = FlatColumn::int64('id');
+        $schema = Schema::with($id, NestedColumn::struct('address', [$city]), FlatColumn::int64('other'));
+        $builders = ColumnChunkBuilders::initialize(
+            $schema,
+            (new Options())->set(Option::COLUMNS_BLOOM_FILTERS, [
+                'id' => new BloomFilterOptions(),
+                'address.city' => new BloomFilterOptions(),
+            ]),
+            Compressions::UNCOMPRESSED,
+        );
+        $ids = new WriteFlatColumnValues($schema->getFlat('id'));
+        $ids->addRaw(0, 1, 7);
+        $ids->addRaw(0, 0, null);
+        $cities = new WriteFlatColumnValues($schema->getFlat('address.city'));
+        $cities->addRaw(0, 2, 'Oslo');
+        $cities->addRaw(0, 0, null);
+        $others = new WriteFlatColumnValues($schema->getFlat('other'));
+        $others->addRaw(0, 1, 1);
+        $others->addRaw(0, 1, 2);
+        $builders->addColumnByFlatPath('id', $ids);
+        $builders->addColumnByFlatPath('address.city', $cities);
+        $builders->addColumnByFlatPath('other', $others);
+
+        $bloomFilters = [];
+
+        foreach ($builders->flush(4) as $container) {
+            $bloomFilters[$container->columnChunk->flatPath()] = $container->bloomFilter;
+        }
+
+        static::assertTrue($bloomFilters['id']?->check((new BloomHash())->of($id, 7)));
+        static::assertTrue($bloomFilters['address.city']?->check((new BloomHash())->of($city, 'Oslo')));
+        static::assertNull($bloomFilters['other']);
+
+        foreach ($builders->flush(4) as $container) {
+            $bloomFilters[$container->columnChunk->flatPath()] = $container->bloomFilter;
+        }
+
+        static::assertFalse($bloomFilters['id']?->check((new BloomHash())->of($id, 7)));
+    }
+
+    public function test_a_chunk_without_a_non_null_value_gets_one_empty_block(): void
+    {
+        $schema = Schema::with(FlatColumn::int64('id'));
+        $builders = ColumnChunkBuilders::initialize(
+            $schema,
+            (new Options())->set(Option::COLUMNS_BLOOM_FILTERS, ['id' => new BloomFilterOptions()]),
+            Compressions::UNCOMPRESSED,
+        );
+        $ids = new WriteFlatColumnValues($schema->getFlat('id'));
+        $ids->addRaw(0, 0, null);
+        $builders->addColumnByFlatPath('id', $ids);
+
+        static::assertEquals(Sbbf::fromBytes(str_repeat("\0", Sbbf::BLOCK_BYTES)), $builders->flush(4)[0]->bloomFilter);
+    }
+
+    public function test_a_bloom_filter_option_that_is_not_bloom_filter_options_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'Option COLUMNS_BLOOM_FILTERS takes BloomFilterOptions, got float for column "id"',
+        );
+
+        ColumnChunkBuilders::initialize(
+            Schema::with(FlatColumn::int64('id')),
+            (new Options())->set(Option::COLUMNS_BLOOM_FILTERS, ['id' => 0.05]),
+            Compressions::UNCOMPRESSED,
+        );
+    }
+
     public function test_add_multiple_times_with_same_column(): void
     {
         $options = new Options();
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageBuilder/DictionaryBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageBuilder/DictionaryBuilderTest.php
index 58b5f4aff0..9fe64e04f7 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageBuilder/DictionaryBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageBuilder/DictionaryBuilderTest.php
@@ -339,4 +339,38 @@ public function test_unsupported_physical_type_throws_exception(): void
 
         $this->builder->build($column, $data);
     }
+
+    public function test_a_dictionary_is_extended_with_new_values_and_indexes_old_ones_where_they_are(): void
+    {
+        $column = FlatColumn::string('s');
+        $builder = new DictionaryBuilder();
+        $first = $builder->build($column, new WriteFlatColumnValues($column, values: ['a', 'b']));
+        $second = $builder->build($column, new WriteFlatColumnValues($column, values: ['c', 'a', 'd']), $first);
+
+        static::assertSame(['a', 'b', 'c', 'd'], $second->dictionary);
+        static::assertSame([2, 0, 3], $second->indices);
+    }
+
+    public function test_float_and_object_dictionaries_are_extended_too(): void
+    {
+        $double = FlatColumn::double('d');
+        $builder = new DictionaryBuilder();
+        $floats = $builder->build(
+            $double,
+            new WriteFlatColumnValues($double, values: [2.5, 1.5]),
+            $builder->build($double, new WriteFlatColumnValues($double, values: [1.5])),
+        );
+        $date = FlatColumn::date('day');
+        $first = new DateTimeImmutable('2024-01-01');
+        $dates = $builder->build(
+            $date,
+            new WriteFlatColumnValues($date, values: [new DateTimeImmutable('2024-01-02'), $first]),
+            $builder->build($date, new WriteFlatColumnValues($date, values: [$first])),
+        );
+
+        static::assertSame([1.5, 2.5], $floats->dictionary);
+        static::assertSame([1, 0], $floats->indices);
+        static::assertCount(2, $dates->dictionary);
+        static::assertSame([1, 0], $dates->indices);
+    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageContainersTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageContainersTest.php
index a71f4873dd..1dec58ed94 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageContainersTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageContainersTest.php
@@ -6,12 +6,8 @@
 
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\Encodings;
-use Flow\Parquet\ParquetFile\Page\Header\DataPageHeader;
-use Flow\Parquet\ParquetFile\Page\Header\DataPageHeaderV2;
-use Flow\Parquet\ParquetFile\Page\Header\DictionaryPageHeader;
 use Flow\Parquet\ParquetFile\Page\Header\Type;
-use Flow\Parquet\ParquetFile\Page\PageHeader;
-use Flow\Parquet\Writer\PageContainer;
+use Flow\Parquet\Tests\Mother\PageContainerMother;
 use Flow\Parquet\Writer\PageContainers;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
@@ -54,7 +50,7 @@ public static function page_types_provider(): Generator
     public function test_add_data_page_container(): void
     {
         $containers = new PageContainers();
-        $pageContainer = $this->createDataPageContainer();
+        $pageContainer = PageContainerMother::dataPage();
 
         $containers->add($pageContainer);
 
@@ -66,7 +62,7 @@ public function test_add_data_page_container(): void
     public function test_add_dictionary_page_container(): void
     {
         $containers = new PageContainers();
-        $pageContainer = $this->createDictionaryPageContainer();
+        $pageContainer = PageContainerMother::dictionaryPage();
 
         $containers->add($pageContainer);
 
@@ -77,8 +73,8 @@ public function test_add_dictionary_page_container(): void
     public function test_add_duplicate_dictionary_page_throws_exception(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDictionaryPageContainer();
-        $pageContainer2 = $this->createDictionaryPageContainer();
+        $pageContainer1 = PageContainerMother::dictionaryPage();
+        $pageContainer2 = PageContainerMother::dictionaryPage();
 
         $containers->add($pageContainer1);
 
@@ -91,9 +87,9 @@ public function test_add_duplicate_dictionary_page_throws_exception(): void
     public function test_add_mixed_page_containers(): void
     {
         $containers = new PageContainers();
-        $dataContainer1 = $this->createDataPageContainer();
-        $dictionaryContainer = $this->createDictionaryPageContainer();
-        $dataContainer2 = $this->createDataPageContainer();
+        $dataContainer1 = PageContainerMother::dataPage();
+        $dictionaryContainer = PageContainerMother::dictionaryPage();
+        $dataContainer2 = PageContainerMother::dataPage();
 
         $containers->add($dataContainer1);
         $containers->add($dictionaryContainer);
@@ -108,9 +104,9 @@ public function test_add_mixed_page_containers(): void
     public function test_add_multiple_data_page_containers(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(10);
-        $pageContainer2 = $this->createDataPageContainer(20);
-        $pageContainer3 = $this->createDataPageContainer(30);
+        $pageContainer1 = PageContainerMother::dataPage(10);
+        $pageContainer2 = PageContainerMother::dataPage(20);
+        $pageContainer3 = PageContainerMother::dataPage(30);
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -125,8 +121,8 @@ public function test_add_multiple_data_page_containers(): void
     public function test_buffer_with_data_pages_only(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(valuesCount: 10, pageBuffer: 'data1');
-        $pageContainer2 = $this->createDataPageContainer(valuesCount: 20, pageBuffer: 'data2');
+        $pageContainer1 = PageContainerMother::dataPage(valuesCount: 10, pageBuffer: 'data1');
+        $pageContainer2 = PageContainerMother::dataPage(valuesCount: 20, pageBuffer: 'data2');
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -142,8 +138,8 @@ public function test_buffer_with_data_pages_only(): void
     public function test_buffer_with_dictionary_and_data_pages(): void
     {
         $containers = new PageContainers();
-        $dataContainer = $this->createDataPageContainer(valuesCount: 10, pageBuffer: 'datadata');
-        $dictionaryContainer = $this->createDictionaryPageContainer(valuesCount: 5, pageBuffer: 'dictdata');
+        $dataContainer = PageContainerMother::dataPage(valuesCount: 10, pageBuffer: 'datadata');
+        $dictionaryContainer = PageContainerMother::dictionaryPage(valuesCount: 5, pageBuffer: 'dictdata');
 
         $containers->add($dataContainer);
         $containers->add($dictionaryContainer);
@@ -161,7 +157,7 @@ public function test_buffer_with_dictionary_and_data_pages(): void
     public function test_buffer_with_dictionary_page_only(): void
     {
         $containers = new PageContainers();
-        $dictionaryContainer = $this->createDictionaryPageContainer(valuesCount: 5, pageBuffer: 'data');
+        $dictionaryContainer = PageContainerMother::dictionaryPage(valuesCount: 5, pageBuffer: 'data');
 
         $containers->add($dictionaryContainer);
 
@@ -184,8 +180,8 @@ public function test_buffer_with_empty_containers(): void
     public function test_compressed_size_with_data_pages_only(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(valuesCount: 10, pageBuffer: 'data1');
-        $pageContainer2 = $this->createDataPageContainer(valuesCount: 20, pageBuffer: 'data2');
+        $pageContainer1 = PageContainerMother::dataPage(valuesCount: 10, pageBuffer: 'data1');
+        $pageContainer2 = PageContainerMother::dataPage(valuesCount: 20, pageBuffer: 'data2');
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -199,8 +195,8 @@ public function test_compressed_size_with_data_pages_only(): void
     public function test_compressed_size_with_dictionary_and_data_pages(): void
     {
         $containers = new PageContainers();
-        $dataContainer = $this->createDataPageContainer();
-        $dictionaryContainer = $this->createDictionaryPageContainer();
+        $dataContainer = PageContainerMother::dataPage();
+        $dictionaryContainer = PageContainerMother::dictionaryPage();
 
         $containers->add($dataContainer);
         $containers->add($dictionaryContainer);
@@ -222,9 +218,9 @@ public function test_constructor_with_empty_array(): void
 
     public function test_constructor_with_multiple_data_containers(): void
     {
-        $container1 = $this->createDataPageContainer(10);
-        $container2 = $this->createDataPageContainer(20);
-        $container3 = $this->createDataPageContainer(30);
+        $container1 = PageContainerMother::dataPage(10);
+        $container2 = PageContainerMother::dataPage(20);
+        $container3 = PageContainerMother::dataPage(30);
 
         $containers = new PageContainers([$container1, $container2, $container3]);
 
@@ -240,7 +236,7 @@ public function test_constructor_with_varying_container_counts(int $count): void
         $pageContainers = [];
 
         for ($i = 0; $i < $count; $i++) {
-            $pageContainers[] = $this->createDataPageContainer($i + 1);
+            $pageContainers[] = PageContainerMother::dataPage($i + 1);
         }
 
         $containers = new PageContainers($pageContainers);
@@ -274,7 +270,7 @@ public function test_dictionary_page_container_returns_null_initially(): void
     public function test_encodings_with_data_page_header(): void
     {
         $containers = new PageContainers();
-        $pageContainer = $this->createDataPageContainer();
+        $pageContainer = PageContainerMother::dataPage();
 
         $containers->add($pageContainer);
 
@@ -287,7 +283,7 @@ public function test_encodings_with_data_page_header(): void
     public function test_encodings_with_data_page_header_v2(): void
     {
         $containers = new PageContainers();
-        $pageContainer = $this->createDataPageV2Container();
+        $pageContainer = PageContainerMother::dataPageV2();
 
         $containers->add($pageContainer);
 
@@ -299,7 +295,7 @@ public function test_encodings_with_data_page_header_v2(): void
     public function test_encodings_with_dictionary_page(): void
     {
         $containers = new PageContainers();
-        $pageContainer = $this->createDictionaryPageContainer();
+        $pageContainer = PageContainerMother::dictionaryPage();
 
         $containers->add($pageContainer);
 
@@ -320,9 +316,9 @@ public function test_encodings_with_empty_containers(): void
     public function test_encodings_with_mixed_page_types(): void
     {
         $containers = new PageContainers();
-        $dataContainer = $this->createDataPageContainer();
-        $dictionaryContainer = $this->createDictionaryPageContainer();
-        $dataV2Container = $this->createDataPageV2Container();
+        $dataContainer = PageContainerMother::dataPage();
+        $dictionaryContainer = PageContainerMother::dictionaryPage();
+        $dataV2Container = PageContainerMother::dataPageV2();
 
         $containers->add($dataContainer);
         $containers->add($dictionaryContainer);
@@ -338,8 +334,8 @@ public function test_encodings_with_mixed_page_types(): void
     public function test_encodings_with_multiple_data_pages(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(encoding: Encodings::PLAIN);
-        $pageContainer2 = $this->createDataPageContainer(encoding: Encodings::BIT_PACKED);
+        $pageContainer1 = PageContainerMother::dataPage(encoding: Encodings::PLAIN);
+        $pageContainer2 = PageContainerMother::dataPage(encoding: Encodings::BIT_PACKED);
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -354,8 +350,8 @@ public function test_encodings_with_multiple_data_pages(): void
     public function test_encodings_with_unique_values_only(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(encoding: Encodings::PLAIN);
-        $pageContainer2 = $this->createDataPageContainer(encoding: Encodings::PLAIN);
+        $pageContainer1 = PageContainerMother::dataPage(encoding: Encodings::PLAIN);
+        $pageContainer2 = PageContainerMother::dataPage(encoding: Encodings::PLAIN);
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -370,8 +366,8 @@ public function test_encodings_with_unique_values_only(): void
     public function test_uncompressed_size_with_data_pages_only(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(valuesCount: 10, pageBuffer: 'data1');
-        $pageContainer2 = $this->createDataPageContainer(valuesCount: 20, pageBuffer: 'data2');
+        $pageContainer1 = PageContainerMother::dataPage(valuesCount: 10, pageBuffer: 'data1');
+        $pageContainer2 = PageContainerMother::dataPage(valuesCount: 20, pageBuffer: 'data2');
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -385,8 +381,8 @@ public function test_uncompressed_size_with_data_pages_only(): void
     public function test_uncompressed_size_with_dictionary_and_data_pages(): void
     {
         $containers = new PageContainers();
-        $dataContainer = $this->createDataPageContainer();
-        $dictionaryContainer = $this->createDictionaryPageContainer();
+        $dataContainer = PageContainerMother::dataPage();
+        $dictionaryContainer = PageContainerMother::dictionaryPage();
 
         $containers->add($dataContainer);
         $containers->add($dictionaryContainer);
@@ -409,9 +405,9 @@ public function test_uncompressed_size_with_empty_containers(): void
     public function test_values_count_with_data_pages_only(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(valuesCount: 10);
-        $pageContainer2 = $this->createDataPageContainer(valuesCount: 20);
-        $pageContainer3 = $this->createDataPageContainer(valuesCount: 30);
+        $pageContainer1 = PageContainerMother::dataPage(valuesCount: 10);
+        $pageContainer2 = PageContainerMother::dataPage(valuesCount: 20);
+        $pageContainer3 = PageContainerMother::dataPage(valuesCount: 30);
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -425,8 +421,8 @@ public function test_values_count_with_data_pages_only(): void
     public function test_values_count_with_dictionary_and_data_pages(): void
     {
         $containers = new PageContainers();
-        $dataContainer = $this->createDataPageContainer(valuesCount: 15);
-        $dictionaryContainer = $this->createDictionaryPageContainer(valuesCount: 5);
+        $dataContainer = PageContainerMother::dataPage(valuesCount: 15);
+        $dictionaryContainer = PageContainerMother::dictionaryPage(valuesCount: 5);
 
         $containers->add($dataContainer);
         $containers->add($dictionaryContainer);
@@ -448,8 +444,8 @@ public function test_values_count_with_empty_containers(): void
     public function test_values_count_with_zero_value_pages(): void
     {
         $containers = new PageContainers();
-        $pageContainer1 = $this->createDataPageContainer(valuesCount: 0);
-        $pageContainer2 = $this->createDataPageContainer(valuesCount: 0);
+        $pageContainer1 = PageContainerMother::dataPage(valuesCount: 0);
+        $pageContainer2 = PageContainerMother::dataPage(valuesCount: 0);
 
         $containers->add($pageContainer1);
         $containers->add($pageContainer2);
@@ -462,9 +458,9 @@ public function test_values_count_with_zero_value_pages(): void
     public function test_workflow_add_dictionary_then_data_pages(): void
     {
         $containers = new PageContainers();
-        $dictionaryContainer = $this->createDictionaryPageContainer(valuesCount: 3);
-        $dataContainer1 = $this->createDataPageContainer(valuesCount: 10);
-        $dataContainer2 = $this->createDataPageContainer(valuesCount: 20);
+        $dictionaryContainer = PageContainerMother::dictionaryPage(valuesCount: 3);
+        $dataContainer1 = PageContainerMother::dataPage(valuesCount: 10);
+        $dataContainer2 = PageContainerMother::dataPage(valuesCount: 20);
 
         $containers->add($dictionaryContainer);
         $containers->add($dataContainer1);
@@ -481,9 +477,9 @@ public function test_workflow_add_dictionary_then_data_pages(): void
     public function test_workflow_data_pages_only(): void
     {
         $containers = new PageContainers();
-        $dataContainer1 = $this->createDataPageContainer(valuesCount: 5);
-        $dataContainer2 = $this->createDataPageContainer(valuesCount: 10);
-        $dataContainer3 = $this->createDataPageContainer(valuesCount: 15);
+        $dataContainer1 = PageContainerMother::dataPage(valuesCount: 5);
+        $dataContainer2 = PageContainerMother::dataPage(valuesCount: 10);
+        $dataContainer3 = PageContainerMother::dataPage(valuesCount: 15);
 
         $containers->add($dataContainer1);
         $containers->add($dataContainer2);
@@ -497,75 +493,4 @@ public function test_workflow_data_pages_only(): void
         static::assertGreaterThan(0, $containers->uncompressedSize());
         static::assertNotEmpty($containers->encodings());
     }
-
-    private function createDataPageContainer(
-        int $valuesCount = 10,
-        string $pageBuffer = 'pagedata',
-        Encodings $encoding = Encodings::PLAIN,
-    ): PageContainer {
-        $dataPageHeader = new DataPageHeader(
-            encoding: $encoding,
-            repetitionLevelEncoding: Encodings::RLE,
-            definitionLevelEncoding: Encodings::RLE,
-            valuesCount: $valuesCount,
-        );
-
-        $pageHeader = new PageHeader(
-            Type::DATA_PAGE,
-            strlen($pageBuffer),
-            strlen($pageBuffer),
-            dataPageHeader: $dataPageHeader,
-            dataPageHeaderV2: null,
-            dictionaryPageHeader: null,
-        );
-
-        return new PageContainer($pageBuffer, $pageHeader);
-    }
-
-    private function createDataPageV2Container(
-        int $valuesCount = 10,
-        string $pageBuffer = 'pagedata',
-        Encodings $encoding = Encodings::PLAIN,
-    ): PageContainer {
-        $dataPageHeaderV2 = new DataPageHeaderV2(
-            valuesCount: $valuesCount,
-            nullsCount: 0,
-            rowsCount: $valuesCount,
-            encoding: $encoding,
-            definitionsByteLength: 0,
-            repetitionsByteLength: 0,
-            isCompressed: false,
-            statistics: null,
-        );
-
-        $pageHeader = new PageHeader(
-            Type::DATA_PAGE_V2,
-            strlen($pageBuffer),
-            strlen($pageBuffer),
-            dataPageHeader: null,
-            dataPageHeaderV2: $dataPageHeaderV2,
-            dictionaryPageHeader: null,
-        );
-
-        return new PageContainer($pageBuffer, $pageHeader);
-    }
-
-    private function createDictionaryPageContainer(
-        int $valuesCount = 5,
-        string $pageBuffer = 'dictdata',
-        Encodings $encoding = Encodings::RLE_DICTIONARY,
-    ): PageContainer {
-        $dictionaryPageHeader = new DictionaryPageHeader(encoding: $encoding, valuesCount: $valuesCount);
-
-        $pageHeader = new PageHeader(
-            Type::DICTIONARY_PAGE,
-            strlen($pageBuffer),
-            strlen($pageBuffer),
-            dataPageHeader: null,
-            dataPageHeaderV2: null,
-            dictionaryPageHeader: $dictionaryPageHeader,
-        );
-
-        return new PageContainer($pageBuffer, $pageHeader);
-    }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageIndexBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageIndexBuilderTest.php
new file mode 100644
index 0000000000..8dd92054a0
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/PageIndexBuilderTest.php
@@ -0,0 +1,134 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Writer;
+
+use Flow\Parquet\ParquetFile\PageIndex\BoundaryOrder;
+use Flow\Parquet\ParquetFile\PageIndex\ColumnIndex;
+use Flow\Parquet\ParquetFile\PageIndex\OffsetIndex;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Tests\Mother\PageContainerMother;
+use Flow\Parquet\Tests\Mother\StatisticsCounterMother;
+use Flow\Parquet\Writer\PageContainers;
+use Flow\Parquet\Writer\PageIndexBuilder;
+use Flow\Parquet\Writer\StatisticsLevel;
+use Flow\Parquet\Writer\StatisticsTruncation;
+use PHPUnit\Framework\TestCase;
+
+use function pack;
+use function str_repeat;
+use function unpack;
+
+use const NAN;
+
+final class PageIndexBuilderTest extends TestCase
+{
+    public function test_each_page_is_one_entry_and_a_page_without_values_is_a_null_page(): void
+    {
+        $id = FlatColumn::int64('id');
+        $builder = new PageIndexBuilder($id, StatisticsLevel::PAGE, new StatisticsTruncation(64));
+
+        $builder->addPage(StatisticsCounterMother::counted($id, [1, null, 3]), 3);
+        $builder->addPage(StatisticsCounterMother::counted($id, [null, null]), 2);
+        $builder->addPage(StatisticsCounterMother::counted($id, [5, 9]), 2);
+
+        static::assertEquals(
+            new ColumnIndex(
+                [false, true, false],
+                [pack('P', 1), '', pack('P', 5)],
+                [pack('P', 3), '', pack('P', 9)],
+                BoundaryOrder::ASCENDING,
+                [1, 2, 0],
+            ),
+            $builder->columnIndex(),
+        );
+    }
+
+    public function test_the_boundary_order_follows_the_pages_bounds(): void
+    {
+        $id = FlatColumn::int64('id');
+        $descending = new PageIndexBuilder($id, StatisticsLevel::PAGE, new StatisticsTruncation(64));
+        $descending->addPage(StatisticsCounterMother::counted($id, [5, 9]), 2);
+        $descending->addPage(StatisticsCounterMother::counted($id, [1, 3]), 2);
+        $unordered = new PageIndexBuilder($id, StatisticsLevel::PAGE, new StatisticsTruncation(64));
+        $unordered->addPage(StatisticsCounterMother::counted($id, [5, 9]), 2);
+        $unordered->addPage(StatisticsCounterMother::counted($id, [1, 3]), 2);
+        $unordered->addPage(StatisticsCounterMother::counted($id, [4, 10]), 2);
+
+        static::assertSame(BoundaryOrder::DESCENDING, $descending->columnIndex()?->boundaryOrder);
+        static::assertSame(BoundaryOrder::UNORDERED, $unordered->columnIndex()?->boundaryOrder);
+    }
+
+    public function test_float_pages_count_nan_and_an_all_nan_page_has_nan_bounds(): void
+    {
+        $ratio = FlatColumn::double('ratio');
+        $builder = new PageIndexBuilder($ratio, StatisticsLevel::PAGE, new StatisticsTruncation(64));
+
+        $builder->addPage(StatisticsCounterMother::counted($ratio, [1.5, NAN]), 2);
+        $builder->addPage(StatisticsCounterMother::counted($ratio, [NAN]), 1);
+        $index = $builder->columnIndex();
+
+        static::assertSame([1, 1], $index?->nanCounts);
+        static::assertNan(unpack('e', $index->minValues[1])[1]);
+        $id = FlatColumn::int64('id');
+        $integers = new PageIndexBuilder($id, StatisticsLevel::PAGE, new StatisticsTruncation(64));
+        $integers->addPage(StatisticsCounterMother::counted($id, [1]), 1);
+
+        static::assertNull($integers->columnIndex()?->nanCounts);
+    }
+
+    public function test_bytes_bounds_are_truncated_to_the_column_index_length(): void
+    {
+        $name = FlatColumn::string('name');
+        $builder = new PageIndexBuilder($name, StatisticsLevel::PAGE, new StatisticsTruncation(4));
+
+        $builder->addPage(StatisticsCounterMother::counted($name, [str_repeat('a', 10), str_repeat('b', 10)]), 2);
+
+        static::assertSame(['aaaa'], $builder->columnIndex()?->minValues);
+        static::assertSame(['bbbc'], $builder->columnIndex()?->maxValues);
+    }
+
+    public function test_a_page_with_values_but_no_bounds_drops_the_column_index(): void
+    {
+        $timestamp = new FlatColumn('timestamp', PhysicalType::INT96);
+        $builder = new PageIndexBuilder($timestamp, StatisticsLevel::PAGE, new StatisticsTruncation(64));
+
+        $builder->addPage(StatisticsCounterMother::counted($timestamp, [str_repeat("\x01", 12)]), 1);
+
+        static::assertNull($builder->columnIndex());
+    }
+
+    public function test_only_the_page_level_writes_a_column_index(): void
+    {
+        $id = FlatColumn::int64('id');
+
+        foreach ([StatisticsLevel::NONE, StatisticsLevel::CHUNK] as $level) {
+            $builder = new PageIndexBuilder($id, $level, new StatisticsTruncation(64));
+            $builder->addPage(StatisticsCounterMother::counted($id, [1]), 1);
+
+            static::assertNull($builder->columnIndex());
+        }
+    }
+
+    public function test_the_offset_index_locates_each_data_page_and_its_first_row(): void
+    {
+        $id = FlatColumn::int64('id');
+        $builder = new PageIndexBuilder($id, StatisticsLevel::NONE, new StatisticsTruncation(64));
+        $first = PageContainerMother::dataPage(3);
+        $second = PageContainerMother::dataPage(2);
+
+        $builder->addPage(StatisticsCounterMother::counted($id, [1, 2, 3]), 3);
+        $builder->addPage(StatisticsCounterMother::counted($id, [4, 5]), 2);
+
+        static::assertEquals(
+            new OffsetIndex([
+                new PageLocation(100, $first->totalCompressedSize(), 0),
+                new PageLocation(100 + $first->totalCompressedSize(), $second->totalCompressedSize(), 3),
+            ]),
+            $builder->offsetIndex(100, new PageContainers([$first, $second])),
+        );
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/RowGroupBuilderTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/RowGroupBuilderTest.php
index 9eeb7e09df..740cc6e6cb 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/RowGroupBuilderTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/RowGroupBuilderTest.php
@@ -7,10 +7,12 @@
 use Flow\Parquet\Dremel\DremelShredder;
 use Flow\Parquet\Dremel\RowGroupContainer;
 use Flow\Parquet\Dremel\Validator\ColumnDataValidator;
+use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\Option;
 use Flow\Parquet\Options;
 use Flow\Parquet\ParquetFile\Compressions;
 use Flow\Parquet\ParquetFile\Data\DataConverter;
+use Flow\Parquet\ParquetFile\PageIndex\PageLocation;
 use Flow\Parquet\ParquetFile\RowGroup;
 use Flow\Parquet\ParquetFile\Schema;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
@@ -18,8 +20,12 @@
 use Flow\Parquet\Writer\RowGroupBuilder;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 
+use function array_map;
+use function range;
+
 final class RowGroupBuilderTest extends TestCase
 {
     public static function compression_types_provider(): Generator
@@ -390,6 +396,84 @@ public function test_page_check_interval_triggers_page_closing(int $interval): v
         static::assertSame($interval * 2, $builder->rowsCount());
     }
 
+    public function test_pages_close_at_the_maximum_rows_count(): void
+    {
+        $options = (new Options())->set(Option::PAGE_MAXIMUM_ROWS_COUNT, 10)->set(Option::PAGE_SIZE_CHECK_INTERVAL, 5);
+        $builder = new RowGroupBuilder(
+            Schema::with(FlatColumn::int32('id')),
+            Compressions::UNCOMPRESSED,
+            $options,
+            new DremelShredder(new ColumnDataValidator(), DataConverter::initialize($options)),
+        );
+
+        $builder->addRows(array_map(static fn(int $id): array => ['id' => $id], range(1, 25)));
+
+        static::assertSame(
+            [0, 10, 20],
+            array_map(
+                static fn(PageLocation $page): int => $page->firstRowIndex,
+                $builder->flush(0)->offsetIndexes[0]->pages,
+            ),
+        );
+    }
+
+    public function test_a_flushed_row_group_counts_the_next_groups_page_rows_from_zero(): void
+    {
+        $options = (new Options())->set(Option::PAGE_MAXIMUM_ROWS_COUNT, 10)->set(Option::PAGE_SIZE_CHECK_INTERVAL, 5);
+        $builder = new RowGroupBuilder(
+            Schema::with(FlatColumn::int32('id')),
+            Compressions::UNCOMPRESSED,
+            $options,
+            new DremelShredder(new ColumnDataValidator(), DataConverter::initialize($options)),
+        );
+
+        $builder->addRows(array_map(static fn(int $id): array => ['id' => $id], range(1, 25)));
+        $builder->flush(0);
+        $builder->addRows(array_map(static fn(int $id): array => ['id' => $id], range(26, 50)));
+
+        static::assertSame(
+            [0, 10, 20],
+            array_map(
+                static fn(PageLocation $page): int => $page->firstRowIndex,
+                $builder->flush(0)->offsetIndexes[0]->pages,
+            ),
+        );
+    }
+
+    #[TestWith([0])]
+    #[TestWith([-1])]
+    public function test_a_page_maximum_rows_count_below_one_is_refused(int $rows): void
+    {
+        $options = (new Options())->set(Option::PAGE_MAXIMUM_ROWS_COUNT, $rows);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('PAGE_MAXIMUM_ROWS_COUNT must be greater than 0, ' . $rows . ' given');
+
+        new RowGroupBuilder(
+            Schema::with(FlatColumn::int32('id')),
+            Compressions::UNCOMPRESSED,
+            $options,
+            new DremelShredder(new ColumnDataValidator(), DataConverter::initialize($options)),
+        );
+    }
+
+    #[TestWith([0])]
+    #[TestWith([-1])]
+    public function test_a_row_group_size_below_one_byte_is_refused(int $bytes): void
+    {
+        $options = (new Options())->set(Option::ROW_GROUP_SIZE_BYTES, $bytes);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('ROW_GROUP_SIZE_BYTES must be greater than 0, ' . $bytes . ' given');
+
+        new RowGroupBuilder(
+            Schema::with(FlatColumn::int32('id')),
+            Compressions::UNCOMPRESSED,
+            $options,
+            new DremelShredder(new ColumnDataValidator(), DataConverter::initialize($options)),
+        );
+    }
+
     public function test_rows_count_increases_with_each_row(): void
     {
         $schema = Schema::with(FlatColumn::int32('id'));
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsCounterTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsCounterTest.php
index 8bc6968b19..24a70ecc39 100644
--- a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsCounterTest.php
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsCounterTest.php
@@ -4,586 +4,330 @@
 
 namespace Flow\Parquet\Tests\Unit\Writer;
 
+use Flow\Parquet\Binary\ByteOrder;
 use Flow\Parquet\Exception\InvalidArgumentException;
 use Flow\Parquet\ParquetFile\Schema\FlatColumn;
 use Flow\Parquet\ParquetFile\Schema\LogicalType;
 use Flow\Parquet\ParquetFile\Schema\PhysicalType;
-use Flow\Parquet\Writer\StatisticsCounter;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Tests\Mother\StatisticsCounterMother;
 use Generator;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use stdClass;
 
+use function Flow\Parquet\Binary\decode_f64;
 use function pack;
+use function str_repeat;
+use function var_export;
+
+use const NAN;
 
 final class StatisticsCounterTest extends TestCase
 {
-    public static function array_values_provider(): Generator
-    {
-        yield 'empty array' => [[], 1, 0];
-        yield 'single string array' => [['hello'], 1, 5];
-        yield 'multiple strings array' => [['hello', 'world'], 2, 10];
-        yield 'nested array' => [['hello', ['nested', 'array']], 3, 16];
-    }
-
-    public static function comparison_values_provider(): Generator
-    {
-        yield 'integers' => [[5, 1, 10, 3], 1, 10];
-        yield 'strings' => [['zebra', 'apple', 'banana'], 'apple', 'zebra'];
-        yield 'floats' => [[3.14, 1.41, 2.71], 1.41, 3.14];
-        yield 'booleans' => [[true, false, true], false, true];
-        yield 'single value' => [[42], 42, 42];
-    }
-
-    public static function edge_case_values_provider(): Generator
-    {
-        yield 'zero integer' => [0, 1, 0];
-        yield 'zero float' => [0.0, 1, 0];
-        yield 'empty string' => ['', 1, 0];
-        yield 'false boolean' => [false, 1, 0];
-        yield 'array with null' => [[null], 1, 0];
-        yield 'array with mixed nulls' => [[null, 'value', null], 3, 0];
-    }
-
-    public static function simple_values_provider(): Generator
-    {
-        yield 'string value' => ['hello', 5];
-        yield 'integer value' => [42, 0];
-        yield 'float value' => [3.14, 0];
-        yield 'boolean true' => [true, 0];
-        yield 'boolean false' => [false, 0];
-    }
-
     /**
-     * @param array<int|string> $value
+     * @return Generator<string, array{FlatColumn, list<bool|float|int|string>, bool|float|int|string, bool|float|int|string}>
      */
-    #[DataProvider('array_values_provider')]
-    public function test_add_array_values(array $value, int $expectedValuesCount, int $expectedStringLength): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add($value);
-
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame($expectedValuesCount, $statistics->valuesCount());
-        static::assertSame($expectedValuesCount, $statistics->notNullCount());
-    }
-
-    public function test_add_duplicate_values_counts_correctly(): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add('hello');
-        $statistics->add('hello');
-        $statistics->add('world');
-        $statistics->add('hello');
-
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(4, $statistics->valuesCount());
-        static::assertSame(4, $statistics->notNullCount());
-        static::assertSame('hello', $statistics->min());
-        static::assertSame('world', $statistics->max());
+    public static function bounds(): Generator
+    {
+        yield 'integers' => [FlatColumn::int32('c'), [5, 1, 10, 3], 1, 10];
+        yield 'strings' => [FlatColumn::string('c'), ['zebra', 'apple', 'banana'], 'apple', 'zebra'];
+        yield 'digit strings in byte order' => [FlatColumn::string('c'), ['9', '10', '100'], '10', '9'];
+        yield 'floats' => [FlatColumn::double('c'), [3.14, 1.41, 2.71], 1.41, 3.14];
+        yield 'signed zeros' => [FlatColumn::double('c'), [0.0, -0.0], -0.0, 0.0];
+        yield 'booleans' => [FlatColumn::boolean('c'), [true, false, true], false, true];
+        yield 'single value' => [FlatColumn::int64('c'), [42], 42, 42];
+        yield 'descending' => [FlatColumn::int64('c'), [3, 2, 1], 1, 3];
+        yield 'uint64 above PHP_INT_MAX' => [FlatColumnMother::uint64(), [5, -1, 7], 5, -1];
+        yield 'byte array decimal' => [
+            FlatColumnMother::byteArrayDecimal(),
+            ["\x12\xD6\x87", "\xED\x29\x79"],
+            "\xED\x29\x79",
+            "\x12\xD6\x87",
+        ];
     }
 
-    public function test_add_multiple_values_tracks_min_max(): void
-    {
-        $column = FlatColumn::int32('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add(5);
-        $statistics->add(1);
-        $statistics->add(10);
-        $statistics->add(3);
+    /**
+     * @param list<bool|float|int|string> $values
+     */
+    #[DataProvider('bounds')]
+    public function test_bounds_follow_the_physical_order(
+        FlatColumn $column,
+        array $values,
+        bool|float|int|string $min,
+        bool|float|int|string $max,
+    ): void {
+        $statistics = StatisticsCounterMother::counted($column, $values);
 
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(4, $statistics->valuesCount());
-        static::assertSame(4, $statistics->notNullCount());
-        static::assertSame(1, $statistics->min());
-        static::assertSame(10, $statistics->max());
+        static::assertSame(var_export($min, true), var_export($statistics->min(), true));
+        static::assertSame(var_export($max, true), var_export($statistics->max(), true));
     }
 
-    public function test_add_multiple_values_with_nulls(): void
+    public function test_counts_values_and_nulls(): void
     {
-        $column = FlatColumn::int32('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add(5);
-        $statistics->add(null);
-        $statistics->add(10);
-        $statistics->add(null);
-        $statistics->add(3);
+        $statistics = StatisticsCounterMother::counted(FlatColumn::int32('c'), [5, null, 10, null, 3]);
+        $statistics->addNulls(2);
 
-        static::assertSame(2, $statistics->nullCount());
-        static::assertSame(5, $statistics->valuesCount());
+        static::assertSame(4, $statistics->nullCount());
+        static::assertSame(7, $statistics->valuesCount());
         static::assertSame(3, $statistics->notNullCount());
         static::assertSame(3, $statistics->min());
         static::assertSame(10, $statistics->max());
     }
 
-    public function test_add_null_value(): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add(null);
-
-        static::assertSame(1, $statistics->nullCount());
-        static::assertSame(1, $statistics->valuesCount());
-        static::assertSame(0, $statistics->notNullCount());
-        static::assertNull($statistics->min());
-        static::assertNull($statistics->max());
-    }
-
-    public function test_add_nulls_increments_null_and_values_count(): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add('hello');
-        $statistics->addNulls(3);
-
-        static::assertSame(3, $statistics->nullCount());
-        static::assertSame(4, $statistics->valuesCount());
-        static::assertSame(1, $statistics->notNullCount());
-        static::assertSame('hello', $statistics->min());
-        static::assertSame('hello', $statistics->max());
-    }
-
-    public function test_add_nulls_with_negative_throws(): void
+    public function test_negative_null_count_is_refused(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Null count cannot be negative.');
 
-        $statistics->addNulls(-1);
-    }
-
-    public function test_add_nulls_with_zero_is_noop(): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->addNulls(0);
-
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(0, $statistics->valuesCount());
-    }
-
-    public function test_add_object_value(): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-        $object = new stdClass();
-        $object->name = 'test';
-
-        $statistics->add($object);
-
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(1, $statistics->valuesCount());
-        static::assertSame(1, $statistics->notNullCount());
-        static::assertSame($object, $statistics->min());
-        static::assertSame($object, $statistics->max());
+        StatisticsCounterMother::counted(FlatColumn::int32('c'))->addNulls(-1);
     }
 
-    #[DataProvider('simple_values_provider')]
-    public function test_add_simple_values(string|int|float|bool $value, int $expectedStringLength): void
+    public function test_an_object_is_not_a_physical_value(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add($value);
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Column "c" statistics take physical values, got stdClass');
 
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(1, $statistics->valuesCount());
-        static::assertSame(1, $statistics->notNullCount());
-        static::assertSame($value, $statistics->min());
-        static::assertSame($value, $statistics->max());
+        StatisticsCounterMother::counted(FlatColumn::string('c'))->addBatch([new stdClass()]);
     }
 
-    public function test_array_flattening(): void
+    public function test_reset_clears_everything(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        /** @var array<null|bool|float|int|object|string> $nestedArray */
-        $nestedArray = [
-            'level1',
-            [
-                'level2a',
-                [
-                    'level3a',
-                    'level3b',
-                ],
-                'level2b',
-            ],
-            'level1b',
-        ];
-
-        $statistics->add($nestedArray);
-
-        static::assertSame(6, $statistics->valuesCount());
-        static::assertSame('level1', $statistics->min());
-        static::assertSame('level3b', $statistics->max());
-    }
+        $statistics = StatisticsCounterMother::counted(FlatColumn::double('c'), [NAN, null, 1.5]);
 
-    public function test_constructor_initializes_with_empty_values(): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
+        $statistics->reset();
 
-        static::assertSame(0, $statistics->nullCount());
         static::assertSame(0, $statistics->valuesCount());
-        static::assertSame(0, $statistics->notNullCount());
+        static::assertSame(0, $statistics->nullCount());
+        static::assertNull($statistics->nanCount());
         static::assertNull($statistics->min());
         static::assertNull($statistics->max());
     }
 
-    /**
-     * @param null|array<null|bool|float|int|object|string>|bool|float|int|string $value
-     */
-    #[DataProvider('edge_case_values_provider')]
-    public function test_edge_cases(
-        array|string|int|float|bool|null $value,
-        int $expectedValuesCount,
-        int $expectedNullCount,
-    ): void {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
+    public function test_merge_combines_counts_and_bounds(): void
+    {
+        $column = FlatColumn::int64('c');
 
-        $statistics->add($value);
+        $merged = StatisticsCounterMother::counted($column, [
+            5,
+            null,
+        ])->merge(StatisticsCounterMother::counted($column, [1, 9, null]));
 
-        static::assertSame($expectedNullCount, $statistics->nullCount());
-        static::assertSame($expectedValuesCount, $statistics->valuesCount());
+        static::assertSame(5, $merged->valuesCount());
+        static::assertSame(2, $merged->nullCount());
+        static::assertSame(1, $merged->min());
+        static::assertSame(9, $merged->max());
     }
 
-    public function test_merge_preserves_original_statistics(): void
+    public function test_merge_of_a_part_with_a_lower_min_still_checks_its_max(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
+        $column = FlatColumn::int64('c');
 
-        $statistics1->add('hello');
-        $statistics1->add(null);
+        $merged = StatisticsCounterMother::counted($column, [5, 6])->merge(StatisticsCounterMother::counted($column, [
+            1,
+            9,
+        ]));
 
-        $statistics2->add('world');
-
-        $originalNullCount = $statistics1->nullCount();
-        $originalValuesCount = $statistics1->valuesCount();
-
-        $merged = $statistics1->merge($statistics2);
-
-        static::assertSame($originalNullCount, $statistics1->nullCount());
-        static::assertSame($originalValuesCount, $statistics1->valuesCount());
-        static::assertNotSame($statistics1, $merged);
+        static::assertSame(1, $merged->min());
+        static::assertSame(9, $merged->max());
     }
 
-    public function test_merge_with_both_empty_counters(): void
+    public function test_merge_with_an_empty_counter_keeps_the_bounds(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
+        $column = FlatColumn::string('c');
 
-        $merged = $statistics1->merge($statistics2);
+        $merged = StatisticsCounterMother::counted($column)->merge(StatisticsCounterMother::counted($column, [
+            'b',
+            'a',
+        ]));
 
-        static::assertSame(0, $merged->nullCount());
-        static::assertSame(0, $merged->valuesCount());
-        static::assertSame(0, $merged->notNullCount());
-        static::assertNull($merged->min());
-        static::assertNull($merged->max());
+        static::assertSame('a', $merged->min());
+        static::assertSame('b', $merged->max());
+        static::assertNull(
+            StatisticsCounterMother::counted($column)->merge(StatisticsCounterMother::counted($column))->min(),
+        );
     }
 
-    public function test_merge_with_different_column_throws_exception(): void
+    public function test_merge_of_different_columns_is_refused(): void
     {
-        $column1 = FlatColumn::string('column1');
-        $column2 = FlatColumn::string('column2');
-        $statistics1 = new StatisticsCounter($column1);
-        $statistics2 = new StatisticsCounter($column2);
-
         $this->expectException(InvalidArgumentException::class);
         $this->expectExceptionMessage('Cannot merge statistics for different columns.');
 
-        $statistics1->merge($statistics2);
+        StatisticsCounterMother::counted(FlatColumn::string(
+            'a',
+        ))->merge(StatisticsCounterMother::counted(FlatColumn::string('b')));
     }
 
-    public function test_merge_with_different_min_max_values(): void
+    public function test_merge_sums_nan_counts_and_replaces_nan_bounds(): void
     {
-        $column = FlatColumn::int32('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add(5);
-        $statistics1->add(10);
-        $statistics1->add(15);
-
-        $statistics2->add(1);
-        $statistics2->add(20);
-        $statistics2->add(8);
+        $column = FlatColumn::double('d');
 
-        $merged = $statistics1->merge($statistics2);
+        $merged = StatisticsCounterMother::counted($column, [NAN])->merge(StatisticsCounterMother::counted($column, [
+            2.5,
+            NAN,
+        ]));
 
-        static::assertSame(1, $merged->min());
-        static::assertSame(20, $merged->max());
-        static::assertSame(6, $merged->valuesCount());
-        static::assertSame(0, $merged->nullCount());
+        static::assertSame(2, $merged->nanCount());
+        static::assertSame(2.5, $merged->min());
+        static::assertSame(2.5, $merged->max());
     }
 
-    public function test_merge_with_different_null_counts(): void
+    public function test_string_statistics_hold_no_length_prefix_and_no_deprecated_bounds(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add('hello');
-        $statistics1->add(null);
-        $statistics1->add(null);
-        $statistics1->add('world');
+        $result = StatisticsCounterMother::counted(FlatColumn::string('c'), ['hello', 'world'])->toStatistics();
 
-        $statistics2->add('foo');
-        $statistics2->add(null);
-
-        $merged = $statistics1->merge($statistics2);
-
-        static::assertSame(3, $merged->nullCount());
-        static::assertSame(6, $merged->valuesCount());
-        static::assertSame(3, $merged->notNullCount());
+        static::assertNull($result->min);
+        static::assertNull($result->max);
+        static::assertSame('hello', $result->minValue);
+        static::assertSame('world', $result->maxValue);
+        static::assertTrue($result->isMinValueExact);
+        static::assertTrue($result->isMaxValueExact);
     }
 
-    public function test_merge_with_different_values_counts(): void
+    public function test_byte_array_decimal_statistics_are_its_unscaled_bytes(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add('a');
-        $statistics1->add('b');
-
-        $statistics2->add('c');
-        $statistics2->add('d');
-        $statistics2->add('e');
-        $statistics2->add('f');
+        $column = new FlatColumn('c', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::decimal(2, 9));
 
-        $merged = $statistics1->merge($statistics2);
+        $result = StatisticsCounterMother::counted($column, ["\x12\xD6\x87", "\xED\x29\x79"])->toStatistics();
 
-        static::assertSame(0, $merged->nullCount());
-        static::assertSame(6, $merged->valuesCount());
-        static::assertSame(6, $merged->notNullCount());
+        static::assertSame("\xED\x29\x79", $result->min);
+        static::assertSame("\x12\xD6\x87", $result->max);
+        static::assertSame("\xED\x29\x79", $result->minValue);
+        static::assertSame("\x12\xD6\x87", $result->maxValue);
     }
 
-    public function test_merge_with_null_only_counters(): void
+    public function test_all_null_statistics_hold_no_bounds(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add(null);
-        $statistics1->add(null);
-
-        $statistics2->add(null);
-
-        $merged = $statistics1->merge($statistics2);
+        $result = StatisticsCounterMother::counted(FlatColumn::string('c'), [null, null])->toStatistics();
 
-        static::assertSame(3, $merged->nullCount());
-        static::assertSame(3, $merged->valuesCount());
-        static::assertSame(0, $merged->notNullCount());
-        static::assertNull($merged->min());
-        static::assertNull($merged->max());
+        static::assertNull($result->min);
+        static::assertNull($result->maxValue);
+        static::assertSame(2, $result->nullCount);
+        static::assertFalse($result->isMinValueExact);
+        static::assertFalse($result->isMaxValueExact);
+        static::assertNull($result->nanCount);
     }
 
-    public function test_merge_with_one_empty_counter(): void
+    public function test_nan_is_excluded_from_bounds_and_counted(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add('hello');
-        $statistics1->add(null);
-        $statistics1->add('world');
-
-        $merged = $statistics1->merge($statistics2);
+        $result = StatisticsCounterMother::counted(FlatColumn::double('d'), [
+            NAN,
+            -0.0,
+            NAN,
+            0.0,
+            null,
+        ])->toStatistics();
 
-        static::assertSame(1, $merged->nullCount());
-        static::assertSame(3, $merged->valuesCount());
-        static::assertSame(2, $merged->notNullCount());
-        static::assertSame('hello', $merged->min());
-        static::assertSame('world', $merged->max());
+        static::assertSame(2, $result->nanCount);
+        static::assertSame(pack('e', -0.0), $result->minValue);
+        static::assertSame(pack('e', 0.0), $result->maxValue);
+        static::assertNull($result->min);
+        static::assertNull($result->max);
     }
 
-    public function test_merge_with_one_null_only_counter(): void
+    public function test_only_nan_values_give_nan_bounds(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add('hello');
-        $statistics1->add('world');
-
-        $statistics2->add(null);
-        $statistics2->add(null);
-
-        $merged = $statistics1->merge($statistics2);
+        $result = StatisticsCounterMother::counted(FlatColumn::float('f'), [NAN, NAN])->toStatistics();
 
-        static::assertSame(2, $merged->nullCount());
-        static::assertSame(4, $merged->valuesCount());
-        static::assertSame(2, $merged->notNullCount());
-        static::assertSame('hello', $merged->min());
-        static::assertSame('world', $merged->max());
+        static::assertSame(2, $result->nanCount);
+        static::assertSame(pack('g', NAN), $result->minValue);
+        static::assertSame(pack('g', NAN), $result->maxValue);
     }
 
-    public function test_merge_with_same_column(): void
+    public function test_float_without_nan_counts_zero_and_all_null_counts_nothing(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics1 = new StatisticsCounter($column);
-        $statistics2 = new StatisticsCounter($column);
-
-        $statistics1->add('hello');
-        $statistics1->add(null);
-        $statistics1->add('world');
-
-        $statistics2->add('foo');
-        $statistics2->add('bar');
-        $statistics2->add(null);
-
-        $merged = $statistics1->merge($statistics2);
-
-        static::assertSame(2, $merged->nullCount());
-        static::assertSame(6, $merged->valuesCount());
-        static::assertSame(4, $merged->notNullCount());
-    }
-
-    /**
-     * @param array<bool|float|int|string> $values
-     */
-    #[DataProvider('comparison_values_provider')]
-    public function test_min_max_with_different_types(array $values, mixed $expectedMin, mixed $expectedMax): void
-    {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        foreach ($values as $value) {
-            /** @var null|array<null|bool|float|int|object|string>|bool|float|int|object|string $value */
-            $statistics->add($value);
-        }
-
-        static::assertSame($expectedMin, $statistics->min());
-        static::assertSame($expectedMax, $statistics->max());
+        static::assertSame(
+            0,
+            StatisticsCounterMother::counted(FlatColumn::double('d'), [1.5])->toStatistics()->nanCount,
+        );
+        static::assertNull(StatisticsCounterMother::counted(FlatColumn::double('d'), [null])->toStatistics()->nanCount);
+        static::assertNull(StatisticsCounterMother::counted(FlatColumn::int64('i'), [1])->nanCount());
     }
 
-    public function test_not_null_count(): void
+    public function test_page_statistics_of_an_all_null_float_page_count_zero_nans(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add('hello');
-        $statistics->add(null);
-        $statistics->add('world');
-        $statistics->add(null);
-        $statistics->add(['a', 'b']);
-
-        static::assertSame(6, $statistics->valuesCount());
-        static::assertSame(2, $statistics->nullCount());
-        static::assertSame(4, $statistics->notNullCount());
+        static::assertSame(
+            0,
+            StatisticsCounterMother::counted(FlatColumn::double('d'), [null])->toPageStatistics()->nanCount,
+        );
+        static::assertSame(
+            1,
+            StatisticsCounterMother::counted(FlatColumn::double('d'), [NAN])->toPageStatistics()->nanCount,
+        );
+        static::assertNull(StatisticsCounterMother::counted(
+            FlatColumn::int64('i'),
+            [null],
+        )->toPageStatistics()->nanCount);
     }
 
-    public function test_reset(): void
+    public function test_nan_bounds_follow_the_total_order_of_nans(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add('hello');
-        $statistics->add(null);
-        $statistics->add('world');
+        $negativeNan = decode_f64(ByteOrder::LITTLE_ENDIAN, "\x00\x00\x00\x00\x00\x00\xf8\xff")[0];
 
-        static::assertSame(1, $statistics->nullCount());
-        static::assertSame(3, $statistics->valuesCount());
+        $rising = StatisticsCounterMother::counted(FlatColumn::double('d'), [$negativeNan, NAN])->toStatistics();
+        $falling = StatisticsCounterMother::counted(FlatColumn::double('d'), [NAN, $negativeNan])->toStatistics();
 
-        $statistics->reset();
-
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(0, $statistics->valuesCount());
-        static::assertSame(0, $statistics->notNullCount());
-        static::assertNull($statistics->min());
-        static::assertNull($statistics->max());
+        static::assertSame(pack('e', $negativeNan), $rising->minValue);
+        static::assertSame(pack('e', NAN), $rising->maxValue);
+        static::assertSame(pack('e', $negativeNan), $falling->minValue);
+        static::assertSame(pack('e', NAN), $falling->maxValue);
     }
 
-    public function test_to_statistics_encodes_byte_array_without_length_prefix(): void
+    public function test_float16_nan_after_a_value_keeps_the_value_bounds(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add('hello');
-        $statistics->add('world');
-
-        $result = $statistics->toStatistics();
+        $statistics = StatisticsCounterMother::counted(FlatColumnMother::float16(), ["\x00\x3c", "\x00\x7e"]);
 
-        static::assertSame('hello', $result->min);
-        static::assertSame('world', $result->max);
-        static::assertSame('hello', $result->minValue);
-        static::assertSame('world', $result->maxValue);
+        static::assertSame(1, $statistics->nanCount());
+        static::assertSame("\x00\x3c", $statistics->min());
+        static::assertSame("\x00\x3c", $statistics->max());
     }
 
-    public function test_to_statistics_encodes_byte_array_decimal_without_length_prefix(): void
+    public function test_float16_nan_is_counted(): void
     {
-        $statistics = new StatisticsCounter(
-            new FlatColumn('test_column', PhysicalType::BYTE_ARRAY, logicalType: LogicalType::decimal(2, 9)),
-        );
-
-        $statistics->add(12345.67);
-        $statistics->add(-12345.67);
-
-        $result = $statistics->toStatistics();
+        $statistics = StatisticsCounterMother::counted(FlatColumnMother::float16(), ["\x00\x7e", "\x00\x3c"]);
 
-        static::assertSame("\xED\x29\x79", $result->min);
-        static::assertSame("\x12\xD6\x87", $result->max);
-        static::assertSame("\xED\x29\x79", $result->minValue);
-        static::assertSame("\x12\xD6\x87", $result->maxValue);
+        static::assertSame(1, $statistics->nanCount());
+        static::assertSame("\x00\x3c", $statistics->min());
+        static::assertSame("\x00\x3c", $statistics->max());
     }
 
-    public function test_to_statistics_with_int32_encodes_with_packer(): void
+    public function test_deprecated_bounds_are_written_only_for_a_signed_sort_order(): void
     {
-        $column = FlatColumn::int32('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add(5);
-        $statistics->add(10);
+        $bool = StatisticsCounterMother::counted(FlatColumn::boolean('b'), [true, false])->toStatistics();
 
-        $result = $statistics->toStatistics();
-
-        static::assertSame(pack('l', 5), $result->min);
-        static::assertSame(pack('l', 10), $result->max);
+        static::assertSame(
+            pack('P', 1),
+            StatisticsCounterMother::counted(FlatColumn::int64('i'), [1, 2])->toStatistics()->min,
+        );
+        static::assertNull(StatisticsCounterMother::counted(FlatColumnMother::uint64(), [1, 2])->toStatistics()->min);
+        static::assertSame(
+            pack('P', 1),
+            StatisticsCounterMother::counted(FlatColumnMother::uint64(), [1, 2])->toStatistics()->minValue,
+        );
+        static::assertNull($bool->min);
+        static::assertSame("\x00", $bool->minValue);
+        static::assertSame("\x01", $bool->maxValue);
     }
 
-    public function test_to_statistics_with_null_values_does_not_encode(): void
+    public function test_long_string_bounds_are_truncated_and_inexact(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
-
-        $statistics->add(null);
-        $statistics->add(null);
-
-        $result = $statistics->toStatistics();
+        $result = StatisticsCounterMother::counted(FlatColumn::string('s'), [str_repeat('a', 101)])->toStatistics();
 
-        static::assertNull($result->min);
-        static::assertNull($result->max);
-        static::assertNull($result->minValue);
-        static::assertNull($result->maxValue);
-        static::assertSame(2, $result->nullCount);
+        static::assertSame(str_repeat('a', 64), $result->minValue);
+        static::assertSame(str_repeat('a', 63) . 'b', $result->maxValue);
+        static::assertFalse($result->isMinValueExact);
+        static::assertFalse($result->isMaxValueExact);
     }
 
-    public function test_values_count_calculation_with_arrays(): void
+    public function test_interval_writes_no_bounds(): void
     {
-        $column = FlatColumn::string('test_column');
-        $statistics = new StatisticsCounter($column);
+        $result = StatisticsCounterMother::counted(FlatColumnMother::interval(), [str_repeat(
+            "\x01",
+            12,
+        )])->toStatistics();
 
-        $statistics->add(['a', 'b', 'c']);
-        $statistics->add([]);
-        $statistics->add(['d']);
-
-        static::assertSame(5, $statistics->valuesCount());
-        static::assertSame(0, $statistics->nullCount());
-        static::assertSame(5, $statistics->notNullCount());
+        static::assertNull($result->minValue);
+        static::assertNull($result->maxValue);
+        static::assertSame(0, $result->nullCount);
     }
 }
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsOptionsTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsOptionsTest.php
new file mode 100644
index 0000000000..8fdc40e3de
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsOptionsTest.php
@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Writer;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
+use Flow\Parquet\Options;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\Writer\StatisticsLevel;
+use Flow\Parquet\Writer\StatisticsOptions;
+use PHPUnit\Framework\TestCase;
+
+use function str_repeat;
+
+final class StatisticsOptionsTest extends TestCase
+{
+    public function test_chunk_statistics_are_written_unless_the_level_is_none(): void
+    {
+        $id = FlatColumn::int64('id');
+
+        foreach ([
+            [StatisticsLevel::NONE,  false],
+            [StatisticsLevel::CHUNK, true],
+            [StatisticsLevel::PAGE,  true],
+        ] as [$level, $written]) {
+            $statistics = StatisticsOptions::fromOptions((new Options())->set(Option::STATISTICS_LEVEL, $level));
+            $counter = $statistics->counter($id);
+            $counter->addBatch([1]);
+
+            static::assertSame($written, $statistics->chunk($counter) !== null);
+        }
+    }
+
+    public function test_page_header_statistics_need_the_page_level_and_the_option(): void
+    {
+        $id = FlatColumn::int64('id');
+        $options = static fn(
+            StatisticsLevel $level,
+            bool $header,
+        ): StatisticsOptions => StatisticsOptions::fromOptions((new Options())->set(
+            Option::STATISTICS_LEVEL,
+            $level,
+        )->set(Option::PAGE_HEADER_STATISTICS, $header));
+        $counter = $options(StatisticsLevel::PAGE, true)->counter($id);
+        $counter->addBatch([1]);
+
+        static::assertNotNull($options(StatisticsLevel::PAGE, true)->pageHeader($counter));
+        static::assertNull($options(StatisticsLevel::PAGE, false)->pageHeader($counter));
+        static::assertNull($options(StatisticsLevel::CHUNK, true)->pageHeader($counter));
+    }
+
+    public function test_each_page_index_is_new_and_truncates_to_the_column_index_length(): void
+    {
+        $name = FlatColumn::string('name');
+        $statistics = StatisticsOptions::fromOptions((new Options())->set(Option::COLUMN_INDEX_TRUNCATE_LENGTH, 4));
+        $page = $statistics->counter($name);
+        $page->addBatch([str_repeat('a', 10)]);
+        $first = $statistics->pageIndex($name);
+        $first->addPage($page, 1);
+
+        static::assertNotSame($first, $statistics->pageIndex($name));
+        static::assertNull($statistics->pageIndex($name)->columnIndex());
+        static::assertSame(['aaaa'], $first->columnIndex()?->minValues);
+    }
+
+    public function test_a_column_index_truncate_length_below_one_is_refused(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('COLUMN_INDEX_TRUNCATE_LENGTH must be greater than 0, 0 given');
+
+        StatisticsOptions::fromOptions((new Options())->set(Option::COLUMN_INDEX_TRUNCATE_LENGTH, 0));
+    }
+}
diff --git a/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsTruncationTest.php b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsTruncationTest.php
new file mode 100644
index 0000000000..0aaf5e25ca
--- /dev/null
+++ b/src/lib/parquet/tests/Flow/Parquet/Tests/Unit/Writer/StatisticsTruncationTest.php
@@ -0,0 +1,183 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Parquet\Tests\Unit\Writer;
+
+use Flow\Parquet\Exception\InvalidArgumentException;
+use Flow\Parquet\Option;
+use Flow\Parquet\ParquetFile\Schema\FlatColumn;
+use Flow\Parquet\ParquetFile\Schema\PhysicalType;
+use Flow\Parquet\Tests\Mother\FlatColumnMother;
+use Flow\Parquet\Writer\StatisticsTruncation;
+use Generator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\TestWith;
+use PHPUnit\Framework\TestCase;
+
+use function hex2bin;
+use function str_repeat;
+use function strlen;
+
+/**
+ * Cases copied by value from arrow-rs 60 column/writer/mod.rs tests.
+ */
+final class StatisticsTruncationTest extends TestCase
+{
+    /**
+     * @return Generator<string, array{string, string}>
+     */
+    public static function increment_utf8(): Generator
+    {
+        yield 'ascii' => ['hello', 'hellp'];
+        yield '1-byte ending in max 1-byte' => ["a\u{7f}", 'b'];
+        yield 'utf8' => ['❤️🧡💛💚💙💜', '❤️🧡💛💚💙💝'];
+        yield '2-byte without overflow' => ['éééé', 'éééê'];
+        yield '2-byte that overflows lowest byte' => ["\u{ff}\u{ff}", "\u{ff}\u{100}"];
+        yield '2-byte ending in max 2-byte' => ["a\u{7ff}", 'b'];
+        yield '3-byte without overflow' => ['ࠀࠀ', 'ࠀࠁ'];
+        yield '3-byte ending in max 3-byte' => ["a\u{ffff}", 'b'];
+        yield '4-byte without overflow' => ['𐀀𐀀', '𐀀𐀁'];
+        yield '4-byte ending in max unicode' => ["a\u{10ffff}", 'b'];
+        yield 'skips the surrogate range' => ["a\u{D7FF}", 'b'];
+    }
+
+    /**
+     * @return Generator<string, array{string}>
+     */
+    public static function not_incrementable_utf8(): Generator
+    {
+        yield 'max 1-byte' => ["\u{7f}\u{7f}"];
+        yield 'max 2-byte' => ["\u{7ff}\u{7ff}"];
+        yield 'max 3-byte' => ["\u{ffff}\u{ffff}"];
+        yield 'max 4-byte' => ["\u{10ffff}\u{10ffff}"];
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, int, string, string, string}>
+     */
+    public static function truncations(): Generator
+    {
+        $binary = new FlatColumn('b', PhysicalType::BYTE_ARRAY);
+        $utf8 = FlatColumn::string('s');
+
+        yield 'default 64 bytes' => [
+            $binary,
+            64,
+            'This string is longer than 64 bytes, so it will almost certainly be truncated.',
+            'This string is longer than 64 bytes, so it will almost certainly',
+            'This string is longer than 64 bytes, so it will almost certainlz',
+        ];
+        yield 'utf8 1 byte' => [$utf8, 1, 'Blart Versenwald III', 'B', 'C'];
+        yield 'increment' => [$binary, 3, "\x00\x00\x00\x00", "\x00\x00\x00", "\x00\x00\x01"];
+        yield 'increment carries' => [$binary, 3, "\x00\xff\xff\x00", "\x00\xff\xff", "\x01\x00\x00"];
+        yield 'increment max binary chars' => [
+            $binary,
+            5,
+            "\xff\xfe\xfd\xff\xff\x00",
+            "\xff\xfe\xfd\xff\xff",
+            "\xff\xfe\xfe\x00\x00",
+        ];
+        yield 'utf8 sliced at the char boundary' => [$utf8, 13, '❤️🧡💛💚💙💜', '❤️🧡', '❤️🧢'];
+        yield 'ascii truncate and increment' => [$utf8, 8, 'yyyyyyyyy', 'yyyyyyyy', 'yyyyyyyz'];
+        yield '2-byte truncate and increment' => [$utf8, 7, 'ééééé', 'ééé', 'ééê'];
+        yield '2-byte overflowing lowest byte' => [
+            $utf8,
+            8,
+            "\u{ff}\u{ff}\u{ff}\u{ff}\u{ff}",
+            "\u{ff}\u{ff}\u{ff}\u{ff}",
+            "\u{ff}\u{ff}\u{ff}\u{100}",
+        ];
+        yield '3-byte truncate and increment' => [$utf8, 8, 'ࠀࠀࠀࠀ', 'ࠀࠀ', 'ࠀࠁ'];
+        yield '4-byte truncate and increment' => [$utf8, 9, '𐀀𐀀𐀀𐀀', '𐀀𐀀', '𐀀𐀁'];
+        yield 'invalid utf8 falls back to binary' => [
+            $utf8,
+            8,
+            str_repeat("\x80", 32),
+            str_repeat("\x80", 8),
+            str_repeat("\x80", 7) . "\x81",
+        ];
+        yield 'fixed len byte array' => [
+            FlatColumn::fixedSizeByteArray('f', 16),
+            1,
+            (string) hex2bin('0001428a51a8d9cb945f658cee52a7ae'),
+            "\x00",
+            "\x01",
+        ];
+    }
+
+    /**
+     * @return Generator<string, array{FlatColumn, int, string}>
+     */
+    public static function untouched(): Generator
+    {
+        yield 'not longer than the length' => [FlatColumn::string('s'), 9, 'yyyyyyyyy'];
+        yield 'decimal fixed len byte array' => [FlatColumnMother::flbaDecimal(), 1, "\x01\x02"];
+        yield 'float16' => [FlatColumnMother::float16(), 1, "\x00\x3c"];
+        yield 'int64' => [FlatColumn::int64('i'), 1, "\x01\x00\x00\x00\x00\x00\x00\x00"];
+        yield 'one code point longer than the length' => [FlatColumn::string('s'), 1, "\u{0836}"];
+    }
+
+    #[DataProvider('increment_utf8')]
+    public function test_increment_utf8(string $prefix, string $expected): void
+    {
+        static::assertSame($expected, (new StatisticsTruncation(strlen($prefix)))->max(
+            FlatColumn::string('s'),
+            $prefix . 'x',
+        ));
+    }
+
+    #[TestWith([0])]
+    #[TestWith([-1])]
+    public function test_a_length_below_one_is_refused(int $length): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('STATISTICS_TRUNCATE_LENGTH must be greater than 0, ' . $length . ' given');
+
+        new StatisticsTruncation($length);
+    }
+
+    public function test_a_refused_length_names_the_option_it_came_from(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('COLUMN_INDEX_TRUNCATE_LENGTH must be greater than 0, 0 given');
+
+        new StatisticsTruncation(0, Option::COLUMN_INDEX_TRUNCATE_LENGTH);
+    }
+
+    #[DataProvider('not_incrementable_utf8')]
+    public function test_not_incrementable_utf8_max_stays_whole(string $prefix): void
+    {
+        $value = $prefix . 'x';
+
+        static::assertSame($value, (new StatisticsTruncation(strlen($prefix)))->max(FlatColumn::string('s'), $value));
+    }
+
+    public function test_not_incrementable_binary_max_stays_whole(): void
+    {
+        $value = "\xff\xff\xff\x00";
+
+        static::assertSame($value, (new StatisticsTruncation(3))->max(
+            new FlatColumn('b', PhysicalType::BYTE_ARRAY),
+            $value,
+        ));
+    }
+
+    #[DataProvider('truncations')]
+    public function test_truncation(FlatColumn $column, int $length, string $value, string $min, string $max): void
+    {
+        $truncation = new StatisticsTruncation($length);
+
+        static::assertSame($min, $truncation->min($column, $value));
+        static::assertSame($max, $truncation->max($column, $value));
+    }
+
+    #[DataProvider('untouched')]
+    public function test_untouched(FlatColumn $column, int $length, string $value): void
+    {
+        $truncation = new StatisticsTruncation($length);
+
+        static::assertSame($value, $truncation->min($column, $value));
+        static::assertSame($value, $truncation->max($column, $value));
+    }
+}
diff --git a/src/lib/types/src/Flow/Types/Type/Comparator.php b/src/lib/types/src/Flow/Types/Type/Comparator.php
index e5bec56122..10f0973ff9 100644
--- a/src/lib/types/src/Flow/Types/Type/Comparator.php
+++ b/src/lib/types/src/Flow/Types/Type/Comparator.php
@@ -10,6 +10,7 @@
 use Flow\Types\Type\Logical\JsonType;
 use Flow\Types\Type\Logical\ListType;
 use Flow\Types\Type\Logical\MapType;
+use Flow\Types\Type\Logical\NumericStringType;
 use Flow\Types\Type\Logical\OptionalType;
 use Flow\Types\Type\Logical\StructureType;
 use Flow\Types\Type\Logical\TimeType;
@@ -78,6 +79,13 @@ public function comparable(Type $left, Type $right): bool
             return true;
         }
 
+        if ($left instanceof NumericStringType || $right instanceof NumericStringType) {
+            return (
+                in_array($left::class, [StringType::class, NumericStringType::class], true)
+                && in_array($right::class, [StringType::class, NumericStringType::class], true)
+            );
+        }
+
         if (
             in_array($left::class, [StringType::class, JsonType::class], true)
             && in_array($right::class, [StringType::class, JsonType::class], true)
diff --git a/src/lib/types/tests/Flow/Types/Tests/Unit/Type/ComparatorTest.php b/src/lib/types/tests/Flow/Types/Tests/Unit/Type/ComparatorTest.php
index 65e4b2deac..acf29512e3 100644
--- a/src/lib/types/tests/Flow/Types/Tests/Unit/Type/ComparatorTest.php
+++ b/src/lib/types/tests/Flow/Types/Tests/Unit/Type/ComparatorTest.php
@@ -31,6 +31,7 @@
 use function Flow\Types\DSL\type_list;
 use function Flow\Types\DSL\type_map;
 use function Flow\Types\DSL\type_null;
+use function Flow\Types\DSL\type_numeric_string;
 use function Flow\Types\DSL\type_optional;
 use function Flow\Types\DSL\type_string;
 use function Flow\Types\DSL\type_structure;
@@ -52,6 +53,9 @@ public static function type_comparable_data_provider(): Generator
         yield [type_union(type_integer(), type_null()), type_integer()];
         yield [type_union(type_integer(), type_null()), type_float()];
         yield [type_integer(), type_string()];
+        yield [type_numeric_string(), type_string()];
+        yield [type_string(), type_numeric_string()];
+        yield [type_optional(type_numeric_string()), type_string()];
 
         yield [type_array(), type_array()];
         yield [type_array(), type_list(type_string())];
@@ -182,6 +186,9 @@ public static function type_not_comparable_data_provider(): Generator
     {
         yield [type_integer(), type_union(type_float(), type_integer())];
         yield [type_integer(), type_boolean()];
+        yield [type_numeric_string(), type_integer()];
+        yield [type_integer(), type_numeric_string()];
+        yield [type_numeric_string(), type_json()];
         yield [type_array(), type_string()];
         yield [type_array(), type_integer()];
         yield [type_array(), type_boolean()];
diff --git a/src/tools/documentation/src/Flow/Documentation/Models/ParameterModel.php b/src/tools/documentation/src/Flow/Documentation/Models/ParameterModel.php
index 011d11a6ca..7c1520a583 100644
--- a/src/tools/documentation/src/Flow/Documentation/Models/ParameterModel.php
+++ b/src/tools/documentation/src/Flow/Documentation/Models/ParameterModel.php
@@ -6,7 +6,6 @@
 
 use InvalidArgumentException;
 use ReflectionParameter;
-use Throwable;
 
 use function addslashes;
 use function Flow\Types\DSL\type_array;
@@ -69,16 +68,7 @@ public static function fromArray(array $data): self
 
     public static function fromReflection(ReflectionParameter $reflectionParameter): self
     {
-        $defaultValue = null;
-        $hasDefaultValue = false;
-
-        try {
-            $defaultValue = self::exportDefaultValue($reflectionParameter->getDefaultValue());
-            $hasDefaultValue = true;
-        } catch (Throwable) {
-            $hasDefaultValue = false;
-        }
-
+        $hasDefaultValue = $reflectionParameter->isDefaultValueAvailable();
         $reflectionType = $reflectionParameter->getType();
 
         if ($reflectionType === null) {
@@ -91,7 +81,7 @@ public static function fromReflection(ReflectionParameter $reflectionParameter):
             $hasDefaultValue,
             $reflectionParameter->allowsNull(),
             $reflectionParameter->isVariadic(),
-            $defaultValue,
+            $hasDefaultValue ? self::exportDefaultValue($reflectionParameter->getDefaultValue()) : null,
         );
     }
 
diff --git a/src/tools/documentation/tests/Flow/Documentation/Tests/Double/DefaultValues.php b/src/tools/documentation/tests/Flow/Documentation/Tests/Double/DefaultValues.php
new file mode 100644
index 0000000000..8a9c600636
--- /dev/null
+++ b/src/tools/documentation/tests/Flow/Documentation/Tests/Double/DefaultValues.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Documentation\Tests\Double;
+
+final class DefaultValues
+{
+    public function refused(RefusedDefault $value = new RefusedDefault()): void {}
+
+    public function required(int $value): void {}
+
+    public function scalar(int $value = 5): void {}
+}
diff --git a/src/tools/documentation/tests/Flow/Documentation/Tests/Double/RefusedDefault.php b/src/tools/documentation/tests/Flow/Documentation/Tests/Double/RefusedDefault.php
new file mode 100644
index 0000000000..b9ff5285f1
--- /dev/null
+++ b/src/tools/documentation/tests/Flow/Documentation/Tests/Double/RefusedDefault.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Documentation\Tests\Double;
+
+use RuntimeException;
+
+final class RefusedDefault
+{
+    public function __construct()
+    {
+        throw new RuntimeException('The extension refused to load');
+    }
+}
diff --git a/src/tools/documentation/tests/Flow/Documentation/Tests/Unit/Models/ParameterModelTest.php b/src/tools/documentation/tests/Flow/Documentation/Tests/Unit/Models/ParameterModelTest.php
new file mode 100644
index 0000000000..7769aa611d
--- /dev/null
+++ b/src/tools/documentation/tests/Flow/Documentation/Tests/Unit/Models/ParameterModelTest.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Documentation\Tests\Unit\Models;
+
+use Flow\Documentation\Models\ParameterModel;
+use Flow\Documentation\Tests\Double\DefaultValues;
+use PHPUnit\Framework\TestCase;
+use ReflectionParameter;
+use RuntimeException;
+
+final class ParameterModelTest extends TestCase
+{
+    public function test_a_default_value_that_cannot_be_built_propagates(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('The extension refused to load');
+
+        ParameterModel::fromReflection(new ReflectionParameter([DefaultValues::class, 'refused'], 'value'));
+    }
+
+    public function test_a_default_value_is_exported(): void
+    {
+        $parameter = ParameterModel::fromReflection(new ReflectionParameter([DefaultValues::class, 'scalar'], 'value'));
+
+        static::assertTrue($parameter->hasDefaultValue);
+        static::assertSame('5', $parameter->defaultValue);
+    }
+
+    public function test_a_parameter_without_a_default_value_exports_none(): void
+    {
+        $parameter = ParameterModel::fromReflection(
+            new ReflectionParameter([DefaultValues::class, 'required'], 'value'),
+        );
+
+        static::assertFalse($parameter->hasDefaultValue);
+        static::assertNull($parameter->defaultValue);
+    }
+}
diff --git a/web/landing/assets/codemirror/completions/dsl.js b/web/landing/assets/codemirror/completions/dsl.js
index 19c7d7b703..39a2d9dc96 100644
--- a/web/landing/assets/codemirror/completions/dsl.js
+++ b/web/landing/assets/codemirror/completions/dsl.js
@@ -1,7 +1,7 @@
 /**
  * CodeMirror Completer for Flow PHP DSL Functions
  *
- * Total functions: 812
+ * Total functions: 814
  *
  * This completer provides autocompletion for all Flow PHP DSL functions:
  * - Extractors (flow-extractors)
@@ -4492,7 +4492,7 @@ const dslFunctions = [
                     <span class=\"fn-name\">from_pgsql_key_set</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">Client</span> <span class=\"fn-param\">$client</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">Sql|string</span> <span class=\"fn-param\">$query</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">KeySet</span> <span class=\"fn-param\">$keySet</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">array</span> <span class=\"fn-param\">$parameters</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">[]</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">PostgreSqlKeySetExtractor</span>
                 </div>
                                 <div style="color: #8b949e; font-size: 13px;">
-                    Create a PostgreSQL extractor using keyset (cursor-based) pagination.<br>More efficient than LIMIT/OFFSET for large datasets - uses indexed WHERE conditions<br>instead of skipping rows.<br>@param Client $client PostgreSQL client<br>@param Sql|string $query SQL query to execute (must have ORDER BY matching keyset columns)<br>@param KeySet $keySet Columns to use for keyset pagination<br>@param list<mixed> $parameters Values bound by position to $1, $2, ... placeholders; wrap with {@see \\Flow\\PostgreSql\\DSL\\typed()} to force a specific PostgreSQL type
+                    Create a PostgreSQL extractor using keyset (cursor-based) pagination.<br>More efficient than LIMIT/OFFSET for large datasets - uses indexed WHERE conditions<br>instead of skipping rows.<br>@param Client $client PostgreSQL client<br>@param Sql|string $query SQL query to execute (ORDER BY optional; when present it must equal the keys; no LIMIT/OFFSET; keys indexed, non-null, unique)<br>@param KeySet $keySet Columns to use for keyset pagination<br>@param list<mixed> $parameters Values bound by position to $1, $2, ... placeholders; wrap with {@see \\Flow\\PostgreSql\\DSL\\typed()} to force a specific PostgreSQL type
                 </div>
                             `
             return div
@@ -5953,7 +5953,7 @@ const dslFunctions = [
                     <span class=\"fn-name\">list_schema</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">string</span> <span class=\"fn-param\">$name</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">ListType|Type</span> <span class=\"fn-param\">$type</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">bool</span> <span class=\"fn-param\">$nullable</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">false</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">Metadata</span> <span class=\"fn-param\">$metadata</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">null</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ListDefinition</span>
                 </div>
                                 <div style="color: #8b949e; font-size: 13px;">
-                    @template T<br>@param ListType<list<T>>|Type<list<T>> $type<br>@return ListDefinition<T>
+                    @template T<br>@param ListType<T>|Type<list<T>> $type<br>@return ListDefinition<T>
                 </div>
                             `
             return div
@@ -6160,7 +6160,7 @@ const dslFunctions = [
                     <span class=\"fn-name\">map_schema</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">string</span> <span class=\"fn-param\">$name</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">MapType|Type</span> <span class=\"fn-param\">$type</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">bool</span> <span class=\"fn-param\">$nullable</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">false</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">Metadata</span> <span class=\"fn-param\">$metadata</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">null</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">MapDefinition</span>
                 </div>
                                 <div style="color: #8b949e; font-size: 13px;">
-                    @template TKey of array-key<br>@template TValue<br>@param MapType<array<TKey, TValue>>|Type<array<TKey, TValue>> $type<br>@return MapDefinition<TKey, TValue>
+                    @template TKey of array-key<br>@template TValue<br>@param MapType<TKey, TValue>|Type<array<TKey, TValue>> $type<br>@return MapDefinition<TKey, TValue>
                 </div>
                             `
             return div
@@ -7217,6 +7217,36 @@ const dslFunctions = [
         },
         apply: snippet("\\Flow\\Telemetry\\DSL\\parent_based_sampler(" + "$" + "{" + "1:root" + "}" + ")"),
         boost: 10
+    },                {
+        label: "parquet_column",
+        type: "function",
+        detail: "flow\u002Ddsl\u002Dhelpers",
+        info: () => {
+            const div = document.createElement("div")
+            div.innerHTML = `
+                <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
+                    <span class=\"fn-name\">parquet_column</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">string</span> <span class=\"fn-param\">$path</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ColumnRef</span>
+                </div>
+                            `
+            return div
+        },
+        apply: snippet("\\Flow\\Parquet\\DSL\\parquet_column(" + "$" + "{" + "1:path" + "}" + ")"),
+        boost: 10
+    },                {
+        label: "parquet_query",
+        type: "function",
+        detail: "flow\u002Ddsl\u002Dhelpers",
+        info: () => {
+            const div = document.createElement("div")
+            div.innerHTML = `
+                <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
+                    <span class=\"fn-name\">parquet_query</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">Query</span>
+                </div>
+                            `
+            return div
+        },
+        apply: snippet("\\Flow\\Parquet\\DSL\\parquet_query()"),
+        boost: 10
     },                {
         label: "parsed_select",
         type: "function",
@@ -10408,7 +10438,7 @@ const dslFunctions = [
                     <span class=\"fn-name\">sql_to_keyset_query</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">string</span> <span class=\"fn-param\">$sql</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">int</span> <span class=\"fn-param\">$limit</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">array</span> <span class=\"fn-param\">$columns</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">array</span> <span class=\"fn-param\">$cursor</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">null</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">string</span>
                 </div>
                                 <div style="color: #8b949e; font-size: 13px;">
-                    Transform a SQL query into a keyset (cursor-based) paginated query.<br>More efficient than OFFSET for large datasets - uses indexed WHERE conditions.<br>Automatically detects existing query parameters and appends keyset placeholders at the end.<br>@param string $sql The SQL query to paginate (must have ORDER BY)<br>@param int $limit Maximum number of rows to return<br>@param list<KeysetColumn> $columns Columns for keyset pagination (must match ORDER BY)<br>@param null|list<null|bool|float|int|string> $cursor Values from last row of previous page (null for first page)<br>@return string The paginated SQL query
+                    Transform a SQL query into a keyset (cursor-based) paginated query.<br>More efficient than OFFSET for large datasets - uses indexed WHERE conditions.<br>Automatically detects existing query parameters and appends keyset placeholders at the end.<br>@param string $sql The SQL query to paginate (ORDER BY optional; when present it must equal the keys; no LIMIT/OFFSET)<br>@param int $limit Maximum number of rows to return<br>@param list<KeysetColumn> $columns Columns for keyset pagination (must match ORDER BY)<br>@param null|list<bool|float|int|string> $cursor Values from last row of previous page (null for first page)<br>@return string The paginated SQL query
                 </div>
                             `
             return div
@@ -11711,9 +11741,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_array</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ArrayType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return ArrayType<array<mixed>>
                 </div>
                             `
             return div
@@ -11765,9 +11792,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_boolean</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">BooleanType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return BooleanType<bool>
                 </div>
                             `
             return div
@@ -11783,9 +11807,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_callable</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">CallableType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return CallableType<callable>
                 </div>
                             `
             return div
@@ -11819,9 +11840,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_date</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">DateType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return DateType<\\DateTimeInterface>
                 </div>
                             `
             return div
@@ -11837,9 +11855,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_datetime</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">DateTimeZone|string</span> <span class=\"fn-param\">$zone</span> <span class=\"fn-operator\">=</span> <span class=\"fn-default\">&#039;UTC&#039;</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">DateTimeType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return DateTimeType<\\DateTimeInterface>
                 </div>
                             `
             return div
@@ -11855,9 +11870,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_empty_array</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">EmptyArrayType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return EmptyArrayType<array{}>
                 </div>
                             `
             return div
@@ -11909,9 +11921,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_float</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">FloatType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return FloatType<float>
                 </div>
                             `
             return div
@@ -11945,9 +11954,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_html</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">HTMLType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return HTMLType<HTMLDocument>
                 </div>
                             `
             return div
@@ -11963,9 +11969,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_html_element</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">HTMLElementType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return HTMLElementType<HTMLElement>
                 </div>
                             `
             return div
@@ -11999,9 +12002,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_integer</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">IntegerType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return IntegerType<int>
                 </div>
                             `
             return div
@@ -12089,9 +12089,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_json</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">JsonType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return JsonType<Json>
                 </div>
                             `
             return div
@@ -12109,7 +12106,7 @@ const dslFunctions = [
                     <span class=\"fn-name\">type_list</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">Type</span> <span class=\"fn-param\">$element</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ListType</span>
                 </div>
                                 <div style="color: #8b949e; font-size: 13px;">
-                    @template T<br>@param Type<T> $element<br>@return ListType<list<T>>
+                    @template T<br>@param Type<T> $element<br>@return ListType<T>
                 </div>
                             `
             return div
@@ -12145,7 +12142,7 @@ const dslFunctions = [
                     <span class=\"fn-name\">type_map</span><span class=\"fn-operator\">(</span><span class=\"fn-type\">Type</span> <span class=\"fn-param\">$key_type</span><span class=\"fn-operator\">,</span> <span class=\"fn-type\">Type</span> <span class=\"fn-param\">$value_type</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">MapType</span>
                 </div>
                                 <div style="color: #8b949e; font-size: 13px;">
-                    @template TKey of array-key<br>@template TValue<br>@param Type<TKey> $key_type<br>@param Type<TValue> $value_type<br>@return MapType<array<TKey, TValue>>
+                    @template TKey of array-key<br>@template TValue<br>@param Type<TKey> $key_type<br>@param Type<TValue> $value_type<br>@return MapType<TKey, TValue>
                 </div>
                             `
             return div
@@ -12179,9 +12176,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_mixed</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">MixedType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return MixedType<mixed>
                 </div>
                             `
             return div
@@ -12197,9 +12191,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_non_empty_string</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">NonEmptyStringType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return NonEmptyStringType<non-empty-string>
                 </div>
                             `
             return div
@@ -12215,9 +12206,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_null</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">NullType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return NullType<null>
                 </div>
                             `
             return div
@@ -12233,9 +12221,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_numeric_string</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">NumericStringType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return NumericStringType<numeric-string>
                 </div>
                             `
             return div
@@ -12251,9 +12236,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_object</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ObjectType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return ObjectType<object>
                 </div>
                             `
             return div
@@ -12287,9 +12269,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_positive_integer</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">PositiveIntegerType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return PositiveIntegerType<int<0, max>>
                 </div>
                             `
             return div
@@ -12305,9 +12284,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_resource</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ResourceType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return ResourceType<resource>
                 </div>
                             `
             return div
@@ -12323,9 +12299,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_scalar</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">ScalarType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return ScalarType<bool|float|int|string>
                 </div>
                             `
             return div
@@ -12341,9 +12314,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_string</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">StringType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return StringType<string>
                 </div>
                             `
             return div
@@ -12377,9 +12347,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_time</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">TimeType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return TimeType<\\DateInterval>
                 </div>
                             `
             return div
@@ -12395,9 +12362,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_time_zone</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">TimeZoneType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return TimeZoneType<\\DateTimeZone>
                 </div>
                             `
             return div
@@ -12431,9 +12395,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_uuid</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">UuidType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return UuidType<Uuid>
                 </div>
                             `
             return div
@@ -12449,9 +12410,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_xml</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">XMLType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return XMLType<\\DOMDocument|XMLDocument>
                 </div>
                             `
             return div
@@ -12467,9 +12425,6 @@ const dslFunctions = [
             div.innerHTML = `
                 <div style="font-family: 'Fira Code', 'JetBrains Mono', monospace; margin-bottom: 8px;">
                     <span class=\"fn-name\">type_xml_element</span><span class=\"fn-operator\">(</span><span class=\"fn-operator\">)</span> <span class=\"fn-operator\">:</span> <span class=\"fn-return\">XMLElementType</span>
-                </div>
-                                <div style="color: #8b949e; font-size: 13px;">
-                    @return XMLElementType<\\DOMElement|Element>
                 </div>
                             `
             return div
diff --git a/web/landing/resources/dsl.json b/web/landing/resources/dsl.json
index 01148095bd..fb8cd013eb 100644
--- a/web/landing/resources/dsl.json
+++ b/web/landing/resources/dsl.json
@@ -1 +1 @@
-[{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":275,"slug":"df","name":"df","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"ConfigBuilder","namespace":"Flow\\ETL\\Config","is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Flow","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"overwrite"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBkYXRhX2ZyYW1lKCkgOiBGbG93LgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":283,"slug":"data-frame","name":"data_frame","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"ConfigBuilder","namespace":"Flow\\ETL\\Config","is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Flow","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"overwrite"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":289,"slug":"telemetry-options","name":"telemetry_options","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"trace_loading","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"trace_transformations","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"trace_cache","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"collect_metrics","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"TelemetryOptions","namespace":"Flow\\ETL\\Config\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":301,"slug":"from-rows","name":"from_rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"rows","type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"RowsExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"overwrite"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":308,"slug":"from-path-partitions","name":"from_path_partitions","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"PathPartitionsExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"partitioning","example":"path_partitions"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":324,"slug":"from-array","name":"from_array","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"iterable","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."},{"name":"spillRoot","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ArrayExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"array"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpdGVyYWJsZTxhcnJheTxtaXhlZD4+ICRhcnJheQogKiBAcGFyYW0gbnVsbHxTY2hlbWEgJHNjaGVtYSAtIEBkZXByZWNhdGVkIHVzZSB3aXRoU2NoZW1hKCkgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIG51bGx8UGF0aCAkc3BpbGxSb290IC0gd2hlcmUgYSBub24tYXJyYXkgJGFycmF5IGlzIHNwaWxsZWQgd2hpbGUgaXQgaXMgZGVzY3JpYmVkOyBudWxsIHJlc29sdmVzIHRvCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAkZmlsZXN5c3RlbS0+Z2V0U3lzdGVtVG1wRGlyKCkgYW5kIG9ubHkgb24gdGhhdCBwYXRoCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":345,"slug":"from-cache","name":"from_cache","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"id","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"fallback_extractor","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"clear","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"cache","type":[{"name":"Cache","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CacheExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBzdHJpbmcgJGlkIC0gY2FjaGUgaWQgZnJvbSB3aGljaCBkYXRhIHdpbGwgYmUgZXh0cmFjdGVkCiAqIEBwYXJhbSBudWxsfEV4dHJhY3RvciAkZmFsbGJhY2tfZXh0cmFjdG9yIC0gZXh0cmFjdG9yIHRoYXQgd2lsbCBiZSB1c2VkIHdoZW4gY2FjaGUgaXMgZW1wdHkgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aEZhbGxiYWNrRXh0cmFjdG9yKCkgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIGJvb2wgJGNsZWFyIC0gY2xlYXIgY2FjaGUgYWZ0ZXIgZXh0cmFjdGlvbiAtIEBkZXByZWNhdGVkIHVzZSB3aXRoQ2xlYXJPbkZpbmlzaCgpIG1ldGhvZCBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":365,"slug":"from-all","name":"from_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"extractors","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ChainExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":371,"slug":"from-memory","name":"from_memory","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"memory","type":[{"name":"Memory","namespace":"Flow\\ETL\\Memory","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MemoryExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":377,"slug":"files","name":"files","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"directory","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FilesExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":383,"slug":"filesystem-cache","name":"filesystem_cache","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"serializer","type":[{"name":"Serializer","namespace":"Flow\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"cache_dir","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FilesystemCache","namespace":"Flow\\ETL\\Cache\\Implementation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":395,"slug":"batched-by","name":"batched_by","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"extractor","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"column","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"min_size","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"BatchByExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBudWxsfGludDwxLCBtYXg+ICRtaW5fc2l6ZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":409,"slug":"batches","name":"batches","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"extractor","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BatchExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpbnQ8MSwgbWF4PiAkc2l6ZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":415,"slug":"from-data-frame","name":"from_data_frame","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"data_frame","type":[{"name":"DataFrame","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DataFrameExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":421,"slug":"from-sequence-date-period","name":"from_sequence_date_period","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"SequenceExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":435,"slug":"from-sequence-date-period-recurrences","name":"from_sequence_date_period_recurrences","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"recurrences","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"SequenceExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":449,"slug":"from-sequence-number","name":"from_sequence_number","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"step","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"}],"return_type":[{"name":"SequenceExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":459,"slug":"to-memory","name":"to_memory","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"memory","type":[{"name":"Memory","namespace":"Flow\\ETL\\Memory","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MemoryLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":473,"slug":"to-array","name":"to_array","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"array"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgcm93cyB0byBhbiBhcnJheSBhbmQgc3RvcmUgdGhlbSBpbiBwYXNzZWQgYXJyYXkgdmFyaWFibGUuCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPiAkYXJyYXkKICoKICogQHBhcmFtLW91dCBhcnJheTxhcnJheTxtaXhlZD4+ICRhcnJheQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":481,"slug":"to-output","name":"to_output","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":491,"slug":"to-stderr","name":"to_stderr","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":501,"slug":"to-stdout","name":"to_stdout","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":511,"slug":"to-stream","name":"to_stream","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"uri","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"mode","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'w'"},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":531,"slug":"to-transformation","name":"to_transformation","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"transformer","type":[{"name":"Transformer","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Transformation","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sink","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Transformed","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":537,"slug":"to-branch","name":"to_branch","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"condition","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sink","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Branched","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":543,"slug":"rename-style","name":"rename_style","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"style","type":[{"name":"StringStyles","namespace":"Flow\\ETL\\String","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RenameCaseEntryStrategy","namespace":"Flow\\ETL\\Transformer\\Rename","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":553,"slug":"rename-replace","name":"rename_replace","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"search","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"replace","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RenameReplaceEntryStrategy","namespace":"Flow\\ETL\\Transformer\\Rename","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+fHN0cmluZyAkc2VhcmNoCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+fHN0cmluZyAkcmVwbGFjZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":562,"slug":"rename-map","name":"rename_map","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"renames","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RenameMapEntryStrategy","namespace":"Flow\\ETL\\Transformer\\Rename","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIHN0cmluZz4gJHJlbmFtZXMgTWFwIG9mIG9sZF9uYW1lID0+IG5ld19uYW1lCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":568,"slug":"rows","name":"rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"backend","type":[{"name":"Backend","namespace":"Flow\\ETL\\Column","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Column\\AdaptiveBackend::..."}],"return_type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":577,"slug":"col","name":"col","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnresolvedReference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFuIGFsaWFzIGZvciBgcmVmYC4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":587,"slug":"entry","name":"entry","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnresolvedReference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"columns","example":"create"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFuIGFsaWFzIGZvciBgcmVmYC4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":594,"slug":"ref","name":"ref","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnresolvedReference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"columns","example":"create"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":600,"slug":"structure-ref","name":"structure_ref","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StructureFunctions","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":612,"slug":"structure","name":"structure","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Structure","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEJ1aWxkcyBhIHN0cnVjdHVyZSBmcm9tIHNjYWxhciBmdW5jdGlvbnM6IG9uZSBlbGVtZW50IHBlciBrZXksIGluIGtleSBvcmRlci4KICogQW4gZWxlbWVudCBpcyBudWxsYWJsZSB3aGVuIGl0cyBmdW5jdGlvbiBpczsgdGhlIHN0cnVjdHVyZSBpdHNlbGYgbmV2ZXIgaXMuCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIFNjYWxhckZ1bmN0aW9uPiAkZWxlbWVudHMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":618,"slug":"list-ref","name":"list_ref","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ListFunctions","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":624,"slug":"refs","name":"refs","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":630,"slug":"select","name":"select","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Select","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":636,"slug":"drop","name":"drop","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Drop","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":642,"slug":"add-row-index","name":"add_row_index","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'index'"},{"name":"startFrom","type":[{"name":"StartFrom","namespace":"Flow\\ETL\\Transformation\\AddRowIndex","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Transformation\\AddRowIndex\\StartFrom::..."}],"return_type":[{"name":"AddRowIndex","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":651,"slug":"batch-size","name":"batch_size","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BatchSize","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpbnQ8MSwgbWF4PiAkc2l6ZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":657,"slug":"limit","name":"limit","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Limit","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":666,"slug":"mask-columns","name":"mask_columns","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"mask","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'******'"}],"return_type":[{"name":"MaskColumns","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxpbnQsIHN0cmluZz4gJGNvbHVtbnMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":672,"slug":"optional","name":"optional","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Optional","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":679,"slug":"lit","name":"lit","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Literal","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"columns","example":"create"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":685,"slug":"exists","name":"exists","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Exists","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":691,"slug":"when","name":"when","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"condition","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"then","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"else","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"When","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":700,"slug":"structure-get","name":"structure_get","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGet","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgYXJyYXlfZ2V0YC4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":706,"slug":"array-get","name":"array_get","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGet","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":717,"slug":"structure-get-collection","name":"structure_get_collection","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgYXJyYXlfZ2V0X2NvbGxlY3Rpb25gLgogKgogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58U2NhbGFyRnVuY3Rpb24gJGtleXMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":726,"slug":"array-get-collection","name":"array_get_collection","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAka2V5cwogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":735,"slug":"structure-get-collection-first","name":"structure_get_collection_first","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgYXJyYXlfZ2V0X2NvbGxlY3Rpb25fZmlyc3RgLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":741,"slug":"array-get-collection-first","name":"array_get_collection_first","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":750,"slug":"array-exists","name":"array_exists","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayPathExists","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkcmVmCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":760,"slug":"array-merge","name":"array_merge","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"left","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayMerge","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkbGVmdAogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58U2NhbGFyRnVuY3Rpb24gJHJpZ2h0CiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":769,"slug":"array-merge-collection","name":"array_merge_collection","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayMergeCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkYXJyYXkKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":775,"slug":"array-key-rename","name":"array_key_rename","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"newName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayKeyRename","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":781,"slug":"array-keys-style-convert","name":"array_keys_style_convert","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"style","type":[{"name":"StringStyles","namespace":"Flow\\ETL\\String","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\String\\StringStyles::..."}],"return_type":[{"name":"ArrayKeysStyleConvert","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":789,"slug":"array-sort","name":"array_sort","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sort_function","type":[{"name":"Sort","namespace":"Flow\\ETL\\Function\\ArraySort","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"flags","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"recursive","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"ArraySort","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":802,"slug":"array-reverse","name":"array_reverse","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"preserveKeys","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"ArrayReverse","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkZnVuY3Rpb24KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":808,"slug":"now","name":"now","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"time_zone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"DateTimeZone::..."}],"return_type":[{"name":"Now","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":814,"slug":"between","name":"between","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"lower_bound","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"upper_bound","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"boundary","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"Boundary","namespace":"Flow\\ETL\\Function\\Between","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Function\\Between\\Boundary::..."}],"return_type":[{"name":"Between","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":824,"slug":"to-date-time","name":"to_date_time","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"format","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d H:i:s'"},{"name":"timeZone","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"DateTimeZone::..."}],"return_type":[{"name":"ToDateTime","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":833,"slug":"to-date","name":"to_date","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"format","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d'"},{"name":"timeZone","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"DateTimeZone::..."}],"return_type":[{"name":"ToDate","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":842,"slug":"date-time-format","name":"date_time_format","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DateTimeFormat","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":848,"slug":"split","name":"split","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"9223372036854775807"}],"return_type":[{"name":"Split","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":861,"slug":"combine","name":"combine","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"keys","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"values","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Combine","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAka2V5cwogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58U2NhbGFyRnVuY3Rpb24gJHZhbHVlcwogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":870,"slug":"concat","name":"concat","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"functions","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Concat","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIENvbmNhdCBhbGwgdmFsdWVzLiBJZiB5b3Ugd2FudCB0byBjb25jYXRlbmF0ZSB2YWx1ZXMgd2l0aCBzZXBhcmF0b3IgdXNlIGNvbmNhdF93cyBmdW5jdGlvbi4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":879,"slug":"concat-ws","name":"concat_ws","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"functions","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ConcatWithSeparator","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIENvbmNhdCBhbGwgdmFsdWVzIHdpdGggc2VwYXJhdG9yLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":885,"slug":"hash","name":"hash","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"algorithm","type":[{"name":"Algorithm","namespace":"Flow\\ETL\\Hash","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Hash\\NativePHPHash::..."}],"return_type":[{"name":"Hash","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":894,"slug":"cast","name":"cast","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Cast","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBcRmxvd1xUeXBlc1xUeXBlPG1peGVkPnxzdHJpbmcgJHR5cGUKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":900,"slug":"coalesce","name":"coalesce","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Coalesce","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":906,"slug":"enum-name","name":"enum_name","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnumName","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":912,"slug":"enum-value","name":"enum_value","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnumValue","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":918,"slug":"count","name":"count","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Count","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":930,"slug":"call","name":"call","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"callable","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"return_type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"CallUserFunc","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIENhbGxzIGEgdXNlci1kZWZpbmVkIGZ1bmN0aW9uIHdpdGggdGhlIGdpdmVuIHBhcmFtZXRlcnMuCiAqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAkcmV0dXJuX3R5cGUKICogQHBhcmFtIGFycmF5PG1peGVkPiAkcGFyYW1ldGVycwogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":957,"slug":"array-unpack","name":"array_unpack","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayUnpack","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIFVucGFja3MgZWFjaCBlbGVtZW50IG9mIGFuIGFycmF5IGludG8gYSBuZXcgZW50cnksIHVzaW5nIHRoZSBhcnJheSBrZXkgYXMgdGhlIGVudHJ5IG5hbWUuCiAqCiAqIEJlZm9yZToKICogKy0tKy0tLS0tLS0tLS0tLS0tLS0tLS0rCiAqIHxpZHwgICAgICAgICAgICAgIGFycmF5fAogKiArLS0rLS0tLS0tLS0tLS0tLS0tLS0tLSsKICogfCAxfHsiYSI6MSwiYiI6MiwiYyI6M318CiAqIHwgMnx7ImQiOjQsImUiOjUsImYiOjZ9fAogKiArLS0rLS0tLS0tLS0tLS0tLS0tLS0tLSsKICoKICogQWZ0ZXI6CiAqICstLSstLS0tLSstLS0tLSstLS0tLSstLS0tLSstLS0tLSsKICogfGlkfGFyci5ifGFyci5jfGFyci5kfGFyci5lfGFyci5mfAogKiArLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rCiAqIHwgMXwgICAgMnwgICAgM3wgICAgIHwgICAgIHwgICAgIHwKICogfCAyfCAgICAgfCAgICAgfCAgICA0fCAgICA1fCAgICA2fAogKiArLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkYXJyYXkKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":987,"slug":"array-expand","name":"array_expand","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"expand","type":[{"name":"ArrayExpand","namespace":"Flow\\ETL\\Function\\ArrayExpand","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Function\\ArrayExpand\\ArrayExpand::..."}],"return_type":[{"name":"ArrayExpand","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEV4cGFuZHMgZWFjaCB2YWx1ZSBpbnRvIGVudHJ5LCBpZiB0aGVyZSBhcmUgbW9yZSB0aGFuIG9uZSB2YWx1ZSwgbXVsdGlwbGUgcm93cyB3aWxsIGJlIGNyZWF0ZWQuCiAqIEFycmF5IGtleXMgYXJlIGlnbm9yZWQsIG9ubHkgdmFsdWVzIGFyZSB1c2VkIHRvIGNyZWF0ZSBuZXcgcm93cy4KICogTmVzdGVkIGluIGFub3RoZXIgZnVuY3Rpb24gKHN0cnVjdHVyZSgpLCBjb25jYXQoKSwgLi4uKSBpdCBzdGlsbCBnaXZlcyBvbmUgcm93IHBlciBlbGVtZW50LiBTZXZlcmFsCiAqIGV4cGFuZHMgaW4gb25lIGV4cHJlc3Npb24gYXJlIHppcHBlZCB0byB0aGUgbG9uZ2VzdCBsaXN0OyBhIHNob3J0ZXIgb25lIGdpdmVzIG51bGwsIHNvIGl0cyBlbGVtZW50CiAqIHR5cGUgYmVjb21lcyBudWxsYWJsZS4gSXQgaXMgcmVmdXNlZCBpbnNpZGUgYW5vdGhlciBhcnJheV9leHBhbmQoKSBhbmQgaW4gZmlsdGVyKCksIHVudGlsKCksCiAqIGR1cGxpY2F0ZVJvdygpLCBhZ2dyZWdhdGUoKSwgb3ZlcigpIGFuZCBvbkVhY2goKS4KICoKICogQmVmb3JlOgogKiAgICstLSstLS0tLS0tLS0tLS0tLS0tLS0tKwogKiAgIHxpZHwgICAgICAgICAgICAgIGFycmF5fAogKiAgICstLSstLS0tLS0tLS0tLS0tLS0tLS0tKwogKiAgIHwgMXx7ImEiOjEsImIiOjIsImMiOjN9fAogKiAgICstLSstLS0tLS0tLS0tLS0tLS0tLS0tKwogKgogKiBBZnRlcjoKICogICArLS0rLS0tLS0tLS0rCiAqICAgfGlkfGV4cGFuZGVkfAogKiAgICstLSstLS0tLS0tLSsKICogICB8IDF8ICAgICAgIDF8CiAqICAgfCAxfCAgICAgICAyfAogKiAgIHwgMXwgICAgICAgM3wKICogICArLS0rLS0tLS0tLS0rCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":993,"slug":"size","name":"size","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Size","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":999,"slug":"uuid-v4","name":"uuid_v4","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Uuid","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1005,"slug":"uuid-v7","name":"uuid_v7","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Uuid","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1011,"slug":"ulid","name":"ulid","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Ulid","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1017,"slug":"lower","name":"lower","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ToLower","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1023,"slug":"capitalize","name":"capitalize","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Capitalize","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1029,"slug":"upper","name":"upper","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ToUpper","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1035,"slug":"all","name":"all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"functions","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1041,"slug":"any","name":"any","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1047,"slug":"not","name":"not","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Not","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1053,"slug":"to-timezone","name":"to_timezone","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"timeZone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ToTimeZone","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1059,"slug":"ignore-error-handler","name":"ignore_error_handler","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"IgnoreError","namespace":"Flow\\ETL\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1065,"slug":"skip-rows-handler","name":"skip_rows_handler","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SkipRows","namespace":"Flow\\ETL\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1071,"slug":"throw-error-handler","name":"throw_error_handler","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"ThrowError","namespace":"Flow\\ETL\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1077,"slug":"regex-replace","name":"regex_replace","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"replacement","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"RegexReplace","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1087,"slug":"regex-match-all","name":"regex_match_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"RegexMatchAll","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1097,"slug":"regex-match","name":"regex_match","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"RegexMatch","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1107,"slug":"regex","name":"regex","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"Regex","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1117,"slug":"regex-all","name":"regex_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"RegexAll","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1127,"slug":"sprintf","name":"sprintf","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"format","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Sprintf","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1133,"slug":"sanitize","name":"sanitize","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"placeholder","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'*'"},{"name":"skipCharacters","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Sanitize","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1142,"slug":"round","name":"round","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2"},{"name":"mode","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"}],"return_type":[{"name":"Round","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1151,"slug":"number-format","name":"number_format","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"decimals","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2"},{"name":"decimal_separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'.'"},{"name":"thousands_separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"','"}],"return_type":[{"name":"NumberFormat","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1164,"slug":"array-to-rows","name":"array_to_rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"backend","type":[{"name":"Backend","namespace":"Flow\\ETL\\Column","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Column\\AdaptiveBackend::..."}],"return_type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheTxtaXhlZD4+fGFycmF5PG1peGVkfHN0cmluZz4gJGRhdGEKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1172,"slug":"rank","name":"rank","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Rank","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"WINDOW_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1178,"slug":"dens-rank","name":"dens_rank","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"DenseRank","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"WINDOW_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1184,"slug":"dense-rank","name":"dense_rank","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"DenseRank","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"WINDOW_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1190,"slug":"average","name":"average","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2"},{"name":"rounding","type":[{"name":"Rounding","namespace":"Flow\\Calculator","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Calculator\\Rounding::..."},{"name":"exact","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Average","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1200,"slug":"greatest","name":"greatest","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Greatest","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1206,"slug":"least","name":"least","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Least","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1212,"slug":"collect","name":"collect","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Collect","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1218,"slug":"string-agg","name":"string_agg","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"', '"},{"name":"sort","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StringAggregate","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1224,"slug":"collect-unique","name":"collect_unique","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CollectUnique","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1230,"slug":"window","name":"window","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Window","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1236,"slug":"unbounded-preceding","name":"unbounded_preceding","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1242,"slug":"preceding","name":"preceding","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1248,"slug":"current-row","name":"current_row","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1254,"slug":"following","name":"following","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1260,"slug":"unbounded-following","name":"unbounded_following","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1266,"slug":"sum","name":"sum","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"exact","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Sum","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1272,"slug":"first","name":"first","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"First","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1278,"slug":"last","name":"last","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Last","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1284,"slug":"max","name":"max","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Max","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1290,"slug":"min","name":"min","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Min","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1296,"slug":"row-number","name":"row_number","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"RowNumber","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1307,"slug":"schema","name":"schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"definitions","type":[{"name":"Definition","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBEZWZpbml0aW9uPG1peGVkPiAuLi4kZGVmaW5pdGlvbnMKICoKICogQHJldHVybiBTY2hlbWEKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1316,"slug":"schema-to-json","name":"schema_to_json","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pretty","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1325,"slug":"schema-to-php","name":"schema_to_php","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"valueFormatter","type":[{"name":"ValueFormatter","namespace":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter\\ValueFormatter::..."},{"name":"typeFormatter","type":[{"name":"TypeFormatter","namespace":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter\\TypeFormatter::..."}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1337,"slug":"schema-to-ascii","name":"schema_to_ascii","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"formatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1347,"slug":"schema-validate","name":"schema_validate","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"expected","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"given","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"validator","type":[{"name":"SchemaValidator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Schema\\Validator\\StrictValidator::..."}],"return_type":[{"name":"ValidationContext","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJGV4cGVjdGVkCiAqIEBwYXJhbSBTY2hlbWEgJGdpdmVuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1356,"slug":"schema-evolving-validator","name":"schema_evolving_validator","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"EvolvingValidator","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1362,"slug":"schema-strict-validator","name":"schema_strict_validator","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"StrictValidator","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1368,"slug":"schema-selective-validator","name":"schema_selective_validator","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SelectiveValidator","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1377,"slug":"schema-from-json","name":"schema_from_json","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gU2NoZW1hCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1390,"slug":"schema-metadata","name":"schema_metadata","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"metadata","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIGFycmF5PGJvb2x8ZmxvYXR8aW50fHN0cmluZz58Ym9vbHxmbG9hdHxpbnR8c3RyaW5nPiAkbWV0YWRhdGEKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1399,"slug":"int-schema","name":"int_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"IntegerDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgaW50ZWdlcl9zY2hlbWFgLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1405,"slug":"integer-schema","name":"integer_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"IntegerDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1414,"slug":"str-schema","name":"str_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StringDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgc3RyaW5nX3NjaGVtYWAuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1420,"slug":"string-schema","name":"string_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StringDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1426,"slug":"bool-schema","name":"bool_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"BooleanDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1432,"slug":"float-schema","name":"float_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FloatDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1446,"slug":"map-schema","name":"map_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"MapType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MapDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUS2V5IG9mIGFycmF5LWtleQogKiBAdGVtcGxhdGUgVFZhbHVlCiAqCiAqIEBwYXJhbSBNYXBUeXBlPFRLZXksIFRWYWx1ZT58VHlwZTxhcnJheTxUS2V5LCBUVmFsdWU+PiAkdHlwZQogKgogKiBAcmV0dXJuIE1hcERlZmluaXRpb248VEtleSwgVFZhbHVlPgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1460,"slug":"list-schema","name":"list_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ListType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ListDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBMaXN0VHlwZTxUPnxUeXBlPGxpc3Q8VD4+ICR0eXBlCiAqCiAqIEByZXR1cm4gTGlzdERlZmluaXRpb248VD4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1478,"slug":"enum-schema","name":"enum_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"EnumDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIFxVbml0RW51bQogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICR0eXBlCiAqCiAqIEByZXR1cm4gRW51bURlZmluaXRpb248VD4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1484,"slug":"null-schema","name":"null_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"NullDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1490,"slug":"datetime-schema","name":"datetime_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"zone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'UTC'"}],"return_type":[{"name":"DateTimeDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1500,"slug":"time-schema","name":"time_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TimeDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1506,"slug":"date-schema","name":"date_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DateDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1512,"slug":"json-schema","name":"json_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"JsonDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1518,"slug":"html-schema","name":"html_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"HTMLDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1524,"slug":"html-element-schema","name":"html_element_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"HTMLElementDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1530,"slug":"xml-schema","name":"xml_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"XMLDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1536,"slug":"xml-element-schema","name":"xml_element_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"XMLElementDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1549,"slug":"structure-schema","name":"structure_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"StructureType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StructureDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBTdHJ1Y3R1cmVUeXBlPGFycmF5PGFycmF5LWtleSwgVD4+fFR5cGU8YXJyYXk8YXJyYXkta2V5LCBUPj4gJHR5cGUKICoKICogQHJldHVybiBTdHJ1Y3R1cmVEZWZpbml0aW9uPFQ+CiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1560,"slug":"uuid-schema","name":"uuid_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"UuidDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1566,"slug":"time-zone-schema","name":"time_zone_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TimeZoneDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1579,"slug":"definition-from-array","name":"definition_from_array","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"definition","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Definition","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERlZmluaXRpb24gZnJvbSBhbiBhcnJheSByZXByZXNlbnRhdGlvbi4KICoKICogQHBhcmFtIGFycmF5PGFycmF5LWtleSwgbWl4ZWQ+ICRkZWZpbml0aW9uCiAqCiAqIEByZXR1cm4gRGVmaW5pdGlvbjxtaXhlZD4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1612,"slug":"definition-from-type","name":"definition_from_type","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Definition","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERlZmluaXRpb24gZnJvbSBhIFR5cGUuCiAqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAkdHlwZQogKgogKiBAcmV0dXJuIERlZmluaXRpb248bWl4ZWQ+CiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1664,"slug":"infer-schema","name":"infer_schema","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SchemaInferenceBuilder","namespace":"Flow\\ETL\\Schema\\Inference","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1670,"slug":"execution-context","name":"execution_context","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FlowContext","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1676,"slug":"flow-context","name":"flow_context","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FlowContext","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1682,"slug":"config","name":"config","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1688,"slug":"config-builder","name":"config_builder","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"ConfigBuilder","namespace":"Flow\\ETL\\Config","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1694,"slug":"memory-sort","name":"memory_sort","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"MemorySortBuilder","namespace":"Flow\\ETL\\Config\\Sort","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1700,"slug":"external-sort","name":"external_sort","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"ExternalSortBuilder","namespace":"Flow\\ETL\\Config\\Sort","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1706,"slug":"hash-join","name":"hash_join","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"HashJoinBuilder","namespace":"Flow\\ETL\\Config\\Join","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1712,"slug":"hash-group-by","name":"hash_group_by","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"HashGroupByBuilder","namespace":"Flow\\ETL\\Config\\Grouping","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1718,"slug":"hash-repartition","name":"hash_repartition","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"HashRepartitionBuilder","namespace":"Flow\\ETL\\Config\\Repartition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1727,"slug":"pivot-values","name":"pivot_values","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"DeclaredPivotValues","namespace":"Flow\\ETL\\GroupBy","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERlY2xhcmVzIHRoZSBwaXZvdCBjb2x1bW5zIGEgZ3JvdXBCeSgpLT5waXZvdCgpIHByb2R1Y2VzLCBzbyB0aGUgcGxhbiBjYW4gbmFtZSB0aGVtIGJlZm9yZSBhIHJvdyBmbG93cy4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1737,"slug":"discover-pivot-values","name":"discover_pivot_values","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"maxValues","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"10000"}],"return_type":[{"name":"DiscoveredPivotValues","namespace":"Flow\\ETL\\GroupBy","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJlYWRzIHRoZSBwaXZvdCBjb2x1bW4gb25jZSBhdCBidWlsZCB0aW1lIGFuZCB0dXJucyB3aGF0IGl0IGZpbmRzIGludG8gZGVjbGFyZWQgdmFsdWVzLiBSZWZ1c2VzIGEKICogc291cmNlIHRoYXQgY2Fubm90IGJlIHJlYWQgdHdpY2UuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1743,"slug":"partition-by","name":"partition_by","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Partitioning","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1752,"slug":"partition-types","name":"partition_types","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"PartitionTypes","namespace":"Flow\\ETL\\Extractor\\File","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAuLi4kdHlwZXMgcGFydGl0aW9uIGNvbHVtbiBuYW1lID0+IHR5cGUsIHBhc3NlZCBhcyBuYW1lZCBhcmd1bWVudHMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1762,"slug":"overwrite","name":"overwrite","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfb3ZlcndyaXRlKCkuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1768,"slug":"save-mode-overwrite","name":"save_mode_overwrite","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1777,"slug":"ignore","name":"ignore","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfaWdub3JlKCkuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1783,"slug":"save-mode-ignore","name":"save_mode_ignore","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1792,"slug":"exception-if-exists","name":"exception_if_exists","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfZXhjZXB0aW9uX2lmX2V4aXN0cygpLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1798,"slug":"save-mode-exception-if-exists","name":"save_mode_exception_if_exists","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1807,"slug":"append","name":"append","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfYXBwZW5kKCkuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1813,"slug":"save-mode-append","name":"save_mode_append","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1819,"slug":"print-rows","name":"print_rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"rows","type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1825,"slug":"identical","name":"identical","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"left","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Identical","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1831,"slug":"equal","name":"equal","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"left","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Equal","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1837,"slug":"compare-all","name":"compare_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"comparison","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"comparisons","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1843,"slug":"compare-any","name":"compare_any","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"comparison","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"comparisons","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1854,"slug":"join-on","name":"join_on","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"comparisons","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"join_prefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"''"}],"return_type":[{"name":"Expression","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"joins","example":"join"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"joins","example":"join_each"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxDb21wYXJpc29ufHN0cmluZz58Q29tcGFyaXNvbiAkY29tcGFyaXNvbnMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1860,"slug":"schema-sort-by-name","name":"schema_sort_by_name","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1869,"slug":"schema-sort-by-type","name":"schema_sort_by_type","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"priorities","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[...]"},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+LCBpbnQ+ICRwcmlvcml0aWVzCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1880,"slug":"schema-sort-by-type-and-name","name":"schema_sort_by_type_and_name","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"priorities","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[...]"},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+LCBpbnQ+ICRwcmlvcml0aWVzCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1891,"slug":"schema-sort-by-metadata","name":"schema_sort_by_metadata","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"key","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1901,"slug":"is-type","name":"is_type","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmd8VHlwZTxtaXhlZD4+fFR5cGU8bWl4ZWQ+ICR0eXBlCiAqIEBwYXJhbSBtaXhlZCAkdmFsdWUKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1935,"slug":"generate-random-string","name":"generate_random_string","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"32"},{"name":"generator","type":[{"name":"RandomValueGenerator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\NativePHPRandomValueGenerator::..."}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1943,"slug":"generate-random-int","name":"generate_random_int","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"start","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"-9223372036854775808"},{"name":"end","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"9223372036854775807"},{"name":"generator","type":[{"name":"RandomValueGenerator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\NativePHPRandomValueGenerator::..."}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1952,"slug":"random-string","name":"random_string","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"length","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"generator","type":[{"name":"RandomValueGenerator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\NativePHPRandomValueGenerator::..."}],"return_type":[{"name":"RandomString","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1960,"slug":"date-interval-to-milliseconds","name":"date_interval_to_milliseconds","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1977,"slug":"date-interval-to-seconds","name":"date_interval_to_seconds","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1994,"slug":"date-interval-to-microseconds","name":"date_interval_to_microseconds","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2011,"slug":"with-entry","name":"with_entry","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"WithEntry","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2017,"slug":"constraint-unique","name":"constraint_unique","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"reference","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"references","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"UniqueConstraint","namespace":"Flow\\ETL\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2023,"slug":"constraint-sorted-by","name":"constraint_sorted_by","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"column","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"SortedByConstraint","namespace":"Flow\\ETL\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2033,"slug":"analyze","name":"analyze","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Analyze","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2042,"slug":"match-cases","name":"match_cases","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"cases","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"default","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MatchCases","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxNYXRjaENvbmRpdGlvbj4gJGNhc2VzCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2048,"slug":"match-condition","name":"match_condition","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"condition","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"then","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MatchCondition","namespace":"Flow\\ETL\\Function\\MatchCases","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2054,"slug":"clock","name":"clock","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"time_zone","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'UTC'"}],"return_type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":31,"slug":"from-floe","name":"from_floe","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"codec","type":[{"name":"Codec","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Floe\\Codec\\NoopCodec::..."},{"name":"chunk_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"65536"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FloeExtractor","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":44,"slug":"to-floe","name":"to_floe","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Floe\\Options::..."},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FloeLoader","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":54,"slug":"floe-options","name":"floe_options","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"buffer_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"65536"},{"name":"codec","type":[{"name":"Codec","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Floe\\Codec\\NoopCodec::..."}],"return_type":[{"name":"Options","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":66,"slug":"merge-floe","name":"merge_floe","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"sources","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"dest","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"backend","type":[{"name":"Backend","namespace":"Flow\\ETL\\Column","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"compact","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"void","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE1lcmdlcyBzZXZlcmFsIEZsb2UgZmlsZXMgKHNhbWUgb3IgYXBwZW5kLWNvbXBhdGlibGUgZXZvbHZpbmcgc2NoZW1hKSBpbnRvIG9uZS4gQnl0ZS1zcGxpY2VzIGZyYW1lCiAqIHJlZ2lvbnMgYnkgZGVmYXVsdCAoTyhieXRlcyksIG5vIHJlLWVuY29kZSk7IGNvbXBhY3QgcmUtZW5jb2RlcyBhbGwgcm93cyBpbnRvIGZld2VyIHNlY3Rpb25zLgogKgogKiBAcGFyYW0gYXJyYXk8aW50LCBQYXRofHN0cmluZz4gJHNvdXJjZXMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/Serializer\/DSL\/functions.php","start_line_in_file":18,"slug":"serialize-to-string","name":"serialize_to_string","namespace":"Flow\\Serializer\\DSL","parameters":[{"name":"serializer","type":[{"name":"Serializer","namespace":"Flow\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"rows","type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/Serializer\/DSL\/functions.php","start_line_in_file":27,"slug":"unserialize-from-string","name":"unserialize_from_string","namespace":"Flow\\Serializer\\DSL","parameters":[{"name":"serializer","type":[{"name":"Serializer","namespace":"Flow\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"payload","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-avro\/src\/Flow\/ETL\/Adapter\/Avro\/functions.php","start_line_in_file":21,"slug":"from-avro","name":"from_avro","namespace":"Flow\\ETL\\DSL\\Adapter\\Avro","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"AvroExtractor","namespace":"Flow\\ETL\\Adapter\\Avro\\FlixTech","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AVRO","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-avro\/src\/Flow\/ETL\/Adapter\/Avro\/functions.php","start_line_in_file":27,"slug":"to-avro","name":"to_avro","namespace":"Flow\\ETL\\DSL\\Adapter\\Avro","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"AvroLoader","namespace":"Flow\\ETL\\Adapter\\Avro\\FlixTech","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AVRO","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":23,"slug":"bar-chart","name":"bar_chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"label","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"datasets","type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BarChart","namespace":"Flow\\ETL\\Adapter\\ChartJS\\Chart","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":29,"slug":"line-chart","name":"line_chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"label","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"datasets","type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"LineChart","namespace":"Flow\\ETL\\Adapter\\ChartJS\\Chart","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":35,"slug":"pie-chart","name":"pie_chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"label","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"datasets","type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PieChart","namespace":"Flow\\ETL\\Adapter\\ChartJS\\Chart","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":41,"slug":"to-chartjs","name":"to_chartjs","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"type","type":[{"name":"Chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ChartJSLoader","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":52,"slug":"to-chartjs-file","name":"to_chartjs_file","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"type","type":[{"name":"Chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"output","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"template","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ChartJSLoader","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDaGFydCAkdHlwZQogKiBAcGFyYW0gbnVsbHxQYXRofHN0cmluZyAkb3V0cHV0IC0gQGRlcHJlY2F0ZWQgdXNlICRsb2FkZXItPndpdGhPdXRwdXRQYXRoKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxQYXRofHN0cmluZyAkdGVtcGxhdGUgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aFRlbXBsYXRlKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":84,"slug":"to-chartjs-var","name":"to_chartjs_var","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"type","type":[{"name":"Chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"output","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ChartJSLoader","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDaGFydCAkdHlwZQogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD4gJG91dHB1dCAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoT3V0cHV0VmFyKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-csv\/src\/Flow\/ETL\/Adapter\/CSV\/functions.php","start_line_in_file":35,"slug":"from-csv","name":"from_csv","namespace":"Flow\\ETL\\Adapter\\CSV","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"empty_to_null","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"separator","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"enclosure","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"escape","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"characters_read_in_line","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"10485760"},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"CSVExtractor","namespace":"Flow\\ETL\\Adapter\\CSV","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CSV","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"csv"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gYm9vbCAkZW1wdHlfdG9fbnVsbCAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRW1wdHlUb051bGwoKSBpbnN0ZWFkCiAqIEBwYXJhbSBib29sICR3aXRoX2hlYWRlciAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoSGVhZGVyKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNlcGFyYXRvciAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoU2VwYXJhdG9yKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGVuY2xvc3VyZSAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRW5jbG9zdXJlKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGVzY2FwZSAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRXNjYXBlKCkgaW5zdGVhZAogKiBAcGFyYW0gaW50PDEsIG1heD4gJGNoYXJhY3RlcnNfcmVhZF9pbl9saW5lIC0gQGRlcHJlY2F0ZWQgdXNlICRsb2FkZXItPndpdGhDaGFyYWN0ZXJzUmVhZEluTGluZSgpIGluc3RlYWQKICogQHBhcmFtIG51bGx8U2NoZW1hICRzY2hlbWEgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aFNjaGVtYSgpIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-csv\/src\/Flow\/ETL\/Adapter\/CSV\/functions.php","start_line_in_file":80,"slug":"to-csv","name":"to_csv","namespace":"Flow\\ETL\\Adapter\\CSV","parameters":[{"name":"uri","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"','"},{"name":"enclosure","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\\"'"},{"name":"escape","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\\\'"},{"name":"new_line_separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\n'"},{"name":"datetime_format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d\\\\TH:i:sP'"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"CSVLoader","namespace":"Flow\\ETL\\Adapter\\CSV","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CSV","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkdXJpCiAqIEBwYXJhbSBib29sICR3aXRoX2hlYWRlciAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoSGVhZGVyKCkgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRzZXBhcmF0b3IgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aFNlcGFyYXRvcigpIGluc3RlYWQKICogQHBhcmFtIHN0cmluZyAkZW5jbG9zdXJlIC0gQGRlcHJlY2F0ZWQgdXNlICRsb2FkZXItPndpdGhFbmNsb3N1cmUoKSBpbnN0ZWFkCiAqIEBwYXJhbSBzdHJpbmcgJGVzY2FwZSAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRXNjYXBlKCkgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRuZXdfbGluZV9zZXBhcmF0b3IgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aE5ld0xpbmVTZXBhcmF0b3IoKSBpbnN0ZWFkCiAqIEBwYXJhbSBzdHJpbmcgJGRhdGV0aW1lX2Zvcm1hdCAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRGF0ZVRpbWVGb3JtYXQoKSBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-csv\/src\/Flow\/ETL\/Adapter\/CSV\/functions.php","start_line_in_file":106,"slug":"csv-detect-separator","name":"csv_detect_separator","namespace":"Flow\\ETL\\Adapter\\CSV","parameters":[{"name":"stream","type":[{"name":"SourceStream","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"lines","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"5"},{"name":"fallback","type":[{"name":"Option","namespace":"Flow\\ETL\\Adapter\\CSV\\Detector","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"Flow\\ETL\\Adapter\\CSV\\Detector\\Option::..."},{"name":"options","type":[{"name":"Options","namespace":"Flow\\ETL\\Adapter\\CSV\\Detector","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Option","namespace":"Flow\\ETL\\Adapter\\CSV\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CSV","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTb3VyY2VTdHJlYW0gJHN0cmVhbSAtIHZhbGlkIHJlc291cmNlIHRvIENTViBmaWxlCiAqIEBwYXJhbSBpbnQ8MSwgbWF4PiAkbGluZXMgLSBudW1iZXIgb2YgbGluZXMgdG8gcmVhZCBmcm9tIENTViBmaWxlLCBkZWZhdWx0IDUsIG1vcmUgbGluZXMgbWVhbnMgbW9yZSBhY2N1cmF0ZSBkZXRlY3Rpb24gYnV0IHNsb3dlciBkZXRlY3Rpb24KICogQHBhcmFtIG51bGx8T3B0aW9uICRmYWxsYmFjayAtIGZhbGxiYWNrIG9wdGlvbiB0byB1c2Ugd2hlbiBubyBiZXN0IG9wdGlvbiBjYW4gYmUgZGV0ZWN0ZWQsIGRlZmF1bHQgaXMgT3B0aW9uKCcsJywgJyInLCAnXFwnKQogKiBAcGFyYW0gbnVsbHxPcHRpb25zICRvcHRpb25zIC0gb3B0aW9ucyB0byB1c2UgZm9yIGRldGVjdGlvbiwgZGVmYXVsdCBpcyBPcHRpb25zOjphbGwoKQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":41,"slug":"dbal-dataframe-factory","name":"dbal_dataframe_factory","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"QueryParameter","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"DbalDataFrameFactory","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPnxDb25uZWN0aW9uICRjb25uZWN0aW9uCiAqIEBwYXJhbSBzdHJpbmcgJHF1ZXJ5CiAqIEBwYXJhbSBRdWVyeVBhcmFtZXRlciAuLi4kcGFyYW1ldGVycwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":61,"slug":"from-dbal-limit-offset","name":"from_dbal_limit_offset","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"Table","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"order_by","type":[{"name":"OrderBy","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"page_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"maximum","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DbalLimitOffsetExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDb25uZWN0aW9uICRjb25uZWN0aW9uCiAqIEBwYXJhbSBzdHJpbmd8VGFibGUgJHRhYmxlCiAqIEBwYXJhbSBhcnJheTxPcmRlckJ5PnxPcmRlckJ5ICRvcmRlcl9ieQogKiBAcGFyYW0gaW50ICRwYWdlX3NpemUgLSBiZWNvbWVzIHRoZSBleHRyYWN0b3IncyBiYXRjaCBzaXplOiByb3dzIHBlciBwYWdlCiAqIEBwYXJhbSBudWxsfGludCAkbWF4aW11bQogKgogKiBAdGhyb3dzIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":88,"slug":"from-dbal-limit-offset-qb","name":"from_dbal_limit_offset_qb","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"queryBuilder","type":[{"name":"QueryBuilder","namespace":"Doctrine\\DBAL\\Query","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"page_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"maximum","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"DbalLimitOffsetExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDb25uZWN0aW9uICRjb25uZWN0aW9uCiAqIEBwYXJhbSBpbnQgJHBhZ2Vfc2l6ZSAtIGJlY29tZXMgdGhlIGV4dHJhY3RvcidzIGJhdGNoIHNpemU6IHJvd3MgcGVyIHBhZ2UKICogQHBhcmFtIG51bGx8aW50ICRtYXhpbXVtIC0gbWF4aW11bSBjYW4gYWxzbyBiZSB0YWtlbiBmcm9tIGEgcXVlcnkgYnVpbGRlciwgJG1heGltdW0gaG93ZXZlciBpcyB1c2VkIHJlZ2FyZGxlc3Mgb2YgdGhlIHF1ZXJ5IGJ1aWxkZXIgaWYgaXQncyBzZXQKICogQHBhcmFtIGludCAkb2Zmc2V0IC0gb2Zmc2V0IGNhbiBhbHNvIGJlIHRha2VuIGZyb20gYSBxdWVyeSBidWlsZGVyLCAkb2Zmc2V0IGhvd2V2ZXIgaXMgdXNlZCByZWdhcmRsZXNzIG9mIHRoZSBxdWVyeSBidWlsZGVyIGlmIGl0J3Mgc2V0IHRvIG5vbiAwIHZhbHVlCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":107,"slug":"from-dbal-key-set-qb","name":"from_dbal_key_set_qb","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"queryBuilder","type":[{"name":"QueryBuilder","namespace":"Doctrine\\DBAL\\Query","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key_set","type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DbalKeySetExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":117,"slug":"from-dbal-queries","name":"from_dbal_queries","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters_set","type":[{"name":"ParametersSet","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBudWxsfFBhcmFtZXRlcnNTZXQgJHBhcmFtZXRlcnNfc2V0IC0gZWFjaCBvbmUgcGFyYW1ldGVycyBhcnJheSB3aWxsIGJlIGV2YWx1YXRlZCBhcyBuZXcgcXVlcnkKICogQHBhcmFtIGFycmF5PGludDwwLCBtYXg+fHN0cmluZywgRGJhbEFycmF5VHlwZXxEYmFsUGFyYW1ldGVyVHlwZXxEYmFsVHlwZXxzdHJpbmc+ICR0eXBlcwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":143,"slug":"dbal-from-queries","name":"dbal_from_queries","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters_set","type":[{"name":"ParametersSet","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBkZXByZWNhdGVkIHVzZSBmcm9tX2RiYWxfcXVlcmllcygpIGluc3RlYWQKICoKICogQHBhcmFtIG51bGx8UGFyYW1ldGVyc1NldCAkcGFyYW1ldGVyc19zZXQgLSBlYWNoIG9uZSBwYXJhbWV0ZXJzIGFycmF5IHdpbGwgYmUgZXZhbHVhdGVkIGFzIG5ldyBxdWVyeQogKiBAcGFyYW0gYXJyYXk8aW50PDAsIG1heD58c3RyaW5nLCBEYmFsQXJyYXlUeXBlfERiYWxQYXJhbWV0ZXJUeXBlfERiYWxUeXBlfHN0cmluZz4gJHR5cGVzCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":157,"slug":"from-dbal-query","name":"from_dbal_query","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPnxsaXN0PG1peGVkPiAkcGFyYW1ldGVycyAtIEBkZXByZWNhdGVkIHVzZSBEYmFsUXVlcnlFeHRyYWN0b3I6OndpdGhQYXJhbWV0ZXJzKCkgaW5zdGVhZAogKiBAcGFyYW0gYXJyYXk8aW50PDAsIG1heD58c3RyaW5nLCBEYmFsQXJyYXlUeXBlfERiYWxQYXJhbWV0ZXJUeXBlfERiYWxUeXBlfHN0cmluZz4gJHR5cGVzIC0gQGRlcHJlY2F0ZWQgdXNlIERiYWxRdWVyeUV4dHJhY3Rvcjo6d2l0aFR5cGVzKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":173,"slug":"dbal-from-query","name":"dbal_from_query","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBkZXByZWNhdGVkIHVzZSBmcm9tX2RiYWxfcXVlcnkoKSBpbnN0ZWFkCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPnxsaXN0PG1peGVkPiAkcGFyYW1ldGVycyAtIEBkZXByZWNhdGVkIHVzZSBEYmFsUXVlcnlFeHRyYWN0b3I6OndpdGhQYXJhbWV0ZXJzKCkgaW5zdGVhZAogKiBAcGFyYW0gYXJyYXk8aW50PDAsIG1heD58c3RyaW5nLCBEYmFsQXJyYXlUeXBlfERiYWxQYXJhbWV0ZXJUeXBlfERiYWxUeXBlfHN0cmluZz4gJHR5cGVzIC0gQGRlcHJlY2F0ZWQgdXNlIERiYWxRdWVyeUV4dHJhY3Rvcjo6d2l0aFR5cGVzKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":199,"slug":"to-dbal-table-insert","name":"to_dbal_table_insert","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"InsertOptions","namespace":"Flow\\Doctrine\\Bulk","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DbalLoader","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"dbal","option":"upsert"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEluc2VydCBuZXcgcm93cyBpbnRvIGEgZGF0YWJhc2UgdGFibGUuCiAqIEluc2VydCBjYW4gYWxzbyBiZSB1c2VkIGFzIGFuIHVwc2VydCB3aXRoIHRoZSBoZWxwIG9mIEluc2VydE9wdGlvbnMuCiAqIEluc2VydE9wdGlvbnMgYXJlIHBsYXRmb3JtIHNwZWNpZmljLCBzbyBwbGVhc2UgY2hvb3NlIHRoZSByaWdodCBvbmUgZm9yIHlvdXIgZGF0YWJhc2UuCiAqCiAqICAtIE15U1FMSW5zZXJ0T3B0aW9ucwogKiAgLSBQb3N0Z3JlU1FMSW5zZXJ0T3B0aW9ucwogKiAgLSBTcWxpdGVJbnNlcnRPcHRpb25zCiAqCiAqIEluIG9yZGVyIHRvIGNvbnRyb2wgdGhlIHNpemUgb2YgdGhlIHNpbmdsZSBpbnNlcnQsIHVzZSBEYXRhRnJhbWU6OmNodW5rU2l6ZSgpIG1ldGhvZCBqdXN0IGJlZm9yZSBjYWxsaW5nIERhdGFGcmFtZTo6bG9hZCgpLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBtaXhlZD58Q29ubmVjdGlvbiAkY29ubmVjdGlvbgogKgogKiBAdGhyb3dzIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":216,"slug":"to-dbal-table-update","name":"to_dbal_table_update","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"UpdateOptions","namespace":"Flow\\Doctrine\\Bulk","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DbalLoader","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqICBVcGRhdGUgZXhpc3Rpbmcgcm93cyBpbiBkYXRhYmFzZS4KICoKICogIEluIG9yZGVyIHRvIGNvbnRyb2wgdGhlIHNpemUgb2YgdGhlIHNpbmdsZSByZXF1ZXN0LCB1c2UgRGF0YUZyYW1lOjpjaHVua1NpemUoKSBtZXRob2QganVzdCBiZWZvcmUgY2FsbGluZyBEYXRhRnJhbWU6OmxvYWQoKS4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fENvbm5lY3Rpb24gJGNvbm5lY3Rpb24KICoKICogQHRocm93cyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24KICov"},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":235,"slug":"to-dbal-table-delete","name":"to_dbal_table_delete","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DbalLoader","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERlbGV0ZSByb3dzIGZyb20gZGF0YWJhc2UgdGFibGUgYmFzZWQgb24gdGhlIHByb3ZpZGVkIGRhdGEuCiAqCiAqIEluIG9yZGVyIHRvIGNvbnRyb2wgdGhlIHNpemUgb2YgdGhlIHNpbmdsZSByZXF1ZXN0LCB1c2UgRGF0YUZyYW1lOjpjaHVua1NpemUoKSBtZXRob2QganVzdCBiZWZvcmUgY2FsbGluZyBEYXRhRnJhbWU6OmxvYWQoKS4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fENvbm5lY3Rpb24gJGNvbm5lY3Rpb24KICoKICogQHRocm93cyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24KICov"},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":250,"slug":"to-dbal-schema-table","name":"to_dbal_schema_table","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table_options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"types_map","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Table","namespace":"Doctrine\\DBAL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnRzIGEgRmxvd1xFVExcU2NoZW1hIHRvIGEgRG9jdHJpbmVcREJBTFxTY2hlbWFcVGFibGUuCiAqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBtaXhlZD4gJHRhYmxlX29wdGlvbnMKICogQHBhcmFtIGFycmF5PGNsYXNzLXN0cmluZzxcRmxvd1xUeXBlc1xUeXBlPG1peGVkPj4sIGNsYXNzLXN0cmluZzxcRG9jdHJpbmVcREJBTFxUeXBlc1xUeXBlPj4gJHR5cGVzX21hcAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":267,"slug":"table-schema-to-flow-schema","name":"table_schema_to_flow_schema","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"table","type":[{"name":"Table","namespace":"Doctrine\\DBAL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"types_map","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnRzIGEgRG9jdHJpbmVcREJBTFxTY2hlbWFcVGFibGUgdG8gYSBGbG93XEVUTFxTY2hlbWEuCiAqCiAqIEBwYXJhbSBhcnJheTxjbGFzcy1zdHJpbmc8XEZsb3dcVHlwZXNcVHlwZTxtaXhlZD4+LCBjbGFzcy1zdHJpbmc8XERvY3RyaW5lXERCQUxcVHlwZXNcVHlwZT4+ICR0eXBlc19tYXAKICoKICogQHJldHVybiBTY2hlbWEKICov"},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":278,"slug":"postgresql-insert-options","name":"postgresql_insert_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"skip_conflicts","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"constraint","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"conflict_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSQLInsertOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"dbal","option":"upsert"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICRjb25mbGljdF9jb2x1bW5zCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":291,"slug":"mysql-insert-options","name":"mysql_insert_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"skip_conflicts","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"upsert","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"MySQLInsertOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":304,"slug":"sqlite-insert-options","name":"sqlite_insert_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"skip_conflicts","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"conflict_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"SqliteInsertOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICRjb25mbGljdF9jb2x1bW5zCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":317,"slug":"postgresql-update-options","name":"postgresql_update_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"primary_key_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSQLUpdateOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICRwcmltYXJ5X2tleV9jb2x1bW5zCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":338,"slug":"to-dbal-transaction","name":"to_dbal_transaction","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sinks","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Transactional","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyaXRlIGV2ZXJ5IHNpbmsgd2l0aGluIGRhdGFiYXNlIHRyYW5zYWN0aW9ucy4KICogRWFjaCBiYXRjaCBvZiByb3dzIGlzIHdyaXR0ZW4gaW4gaXRzIG93biB0cmFuc2FjdGlvbjsgcm93cyBhIHNpbmsncyBUcmFuc2Zvcm1hdGlvbiBkZWxpdmVycyB3aGVuCiAqIHRoZSBydW4gZW5kcyAoYmxvY2tpbmcgb3BlcmF0aW9ucyBkcmFpbiB0aGVyZSkgYXJlIGNvbW1pdHRlZCBpbiBvbmUgZmluYWwgdHJhbnNhY3Rpb24uCiAqIElmIGFueSBzaW5rIGZhaWxzLCB0aGUgb3BlbiB0cmFuc2FjdGlvbiBpcyByb2xsZWQgYmFjay4KICogQSBwbGFpbiBMb2FkZXIgY2hpbGQgaXMgYSBiYXJlIHNpbmsgcm9vdDsgYSB0b190cmFuc2Zvcm1hdGlvbiguLi4pIGNoaWxkIGRlbGl2ZXJzIGluc2lkZSB0aGUgc2FtZQogKiB0cmFuc2FjdGlvbi4gRXZlcnkgY2hpbGQncyBsb2FkZXIgbXVzdCB1c2UgdGhlIHNhbWUgY29ubmVjdGlvbiBhcyB0aGUgdHJhbnNhY3Rpb246IHBhc3Mgb25lIGxpdmUKICogQ29ubmVjdGlvbiB0byBib3RoIC0gYSBsb2FkZXIgYnVpbHQgZnJvbSBhcnJheSBwYXJhbXMgb3BlbnMgaXRzIG93biBjb25uZWN0aW9uIGFuZCBlc2NhcGVzIHRoZQogKiB0cmFuc2FjdGlvbi4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fENvbm5lY3Rpb24gJGNvbm5lY3Rpb24KICogQHBhcmFtIExvYWRlcnxTaW5rIC4uLiRzaW5rcyAtIHNpbmtzIHdyaXR0ZW4gd2l0aGluIHRoZSB0cmFuc2FjdGlvbgogKgogKiBAdGhyb3dzIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":347,"slug":"pagination-key-asc","name":"pagination_key_asc","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ParameterType","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Doctrine\\DBAL\\Types","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Doctrine\\DBAL\\ParameterType::..."}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":353,"slug":"pagination-key-desc","name":"pagination_key_desc","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ParameterType","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Doctrine\\DBAL\\Types","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Doctrine\\DBAL\\ParameterType::..."}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":359,"slug":"pagination-key-set","name":"pagination_key_set","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"keys","type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-excel\/src\/Flow\/ETL\/Adapter\/Excel\/DSL\/functions.php","start_line_in_file":22,"slug":"from-excel","name":"from_excel","namespace":"Flow\\ETL\\Adapter\\Excel\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ExcelExtractor","namespace":"Flow\\ETL\\Adapter\\Excel","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"EXCEL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-excel\/src\/Flow\/ETL\/Adapter\/Excel\/DSL\/functions.php","start_line_in_file":28,"slug":"to-excel","name":"to_excel","namespace":"Flow\\ETL\\Adapter\\Excel\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ExcelLoader","namespace":"Flow\\ETL\\Adapter\\Excel","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"EXCEL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-excel\/src\/Flow\/ETL\/Adapter\/Excel\/DSL\/functions.php","start_line_in_file":34,"slug":"is-valid-excel-sheet-name","name":"is_valid_excel_sheet_name","namespace":"Flow\\ETL\\Adapter\\Excel\\DSL","parameters":[{"name":"sheet_name","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"IsValidExcelSheetName","namespace":"Flow\\ETL\\Adapter\\Excel\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"EXCEL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-google-sheet\/src\/Flow\/ETL\/Adapter\/GoogleSheet\/functions.php","start_line_in_file":22,"slug":"from-google-sheet","name":"from_google_sheet","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","parameters":[{"name":"auth_config","type":[{"name":"Sheets","namespace":"Google\\Service","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"spreadsheet_id","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sheet_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"rows_per_page","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"GoogleSheetExtractor","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"GOOGLE_SHEET","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheXt0eXBlOiBzdHJpbmcsIHByb2plY3RfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXlfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXk6IHN0cmluZywgY2xpZW50X2VtYWlsOiBzdHJpbmcsIGNsaWVudF9pZDogc3RyaW5nLCBhdXRoX3VyaTogc3RyaW5nLCB0b2tlbl91cmk6IHN0cmluZywgYXV0aF9wcm92aWRlcl94NTA5X2NlcnRfdXJsOiBzdHJpbmcsIGNsaWVudF94NTA5X2NlcnRfdXJsOiBzdHJpbmd9fFNoZWV0cyAkYXV0aF9jb25maWcKICogQHBhcmFtIHN0cmluZyAkc3ByZWFkc2hlZXRfaWQKICogQHBhcmFtIHN0cmluZyAkc2hlZXRfbmFtZQogKiBAcGFyYW0gYm9vbCAkd2l0aF9oZWFkZXIgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aEhlYWRlciBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gaW50ICRyb3dzX3Blcl9wYWdlIC0gaG93IG1hbnkgcm93cyBwZXIgcGFnZSB0byBmZXRjaCBmcm9tIEdvb2dsZSBTaGVldHMgQVBJIC0gQGRlcHJlY2F0ZWQgdXNlIHdpdGhSb3dzUGVyUGFnZSBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gYXJyYXl7ZGF0ZVRpbWVSZW5kZXJPcHRpb24\/OiBzdHJpbmcsIG1ham9yRGltZW5zaW9uPzogc3RyaW5nLCB2YWx1ZVJlbmRlck9wdGlvbj86IHN0cmluZ30gJG9wdGlvbnMgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aE9wdGlvbnMgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-google-sheet\/src\/Flow\/ETL\/Adapter\/GoogleSheet\/functions.php","start_line_in_file":56,"slug":"from-google-sheet-columns","name":"from_google_sheet_columns","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","parameters":[{"name":"auth_config","type":[{"name":"Sheets","namespace":"Google\\Service","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"spreadsheet_id","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sheet_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start_range_column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end_range_column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"rows_per_page","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"GoogleSheetExtractor","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"GOOGLE_SHEET","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheXt0eXBlOiBzdHJpbmcsIHByb2plY3RfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXlfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXk6IHN0cmluZywgY2xpZW50X2VtYWlsOiBzdHJpbmcsIGNsaWVudF9pZDogc3RyaW5nLCBhdXRoX3VyaTogc3RyaW5nLCB0b2tlbl91cmk6IHN0cmluZywgYXV0aF9wcm92aWRlcl94NTA5X2NlcnRfdXJsOiBzdHJpbmcsIGNsaWVudF94NTA5X2NlcnRfdXJsOiBzdHJpbmd9fFNoZWV0cyAkYXV0aF9jb25maWcKICogQHBhcmFtIHN0cmluZyAkc3ByZWFkc2hlZXRfaWQKICogQHBhcmFtIHN0cmluZyAkc2hlZXRfbmFtZQogKiBAcGFyYW0gc3RyaW5nICRzdGFydF9yYW5nZV9jb2x1bW4KICogQHBhcmFtIHN0cmluZyAkZW5kX3JhbmdlX2NvbHVtbgogKiBAcGFyYW0gYm9vbCAkd2l0aF9oZWFkZXIgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aEhlYWRlciBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gaW50ICRyb3dzX3Blcl9wYWdlIC0gaG93IG1hbnkgcm93cyBwZXIgcGFnZSB0byBmZXRjaCBmcm9tIEdvb2dsZSBTaGVldHMgQVBJLCBkZWZhdWx0IDEwMDAgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aFJvd3NQZXJQYWdlIG1ldGhvZCBpbnN0ZWFkCiAqIEBwYXJhbSBhcnJheXtkYXRlVGltZVJlbmRlck9wdGlvbj86IHN0cmluZywgbWFqb3JEaW1lbnNpb24\/OiBzdHJpbmcsIHZhbHVlUmVuZGVyT3B0aW9uPzogc3RyaW5nfSAkb3B0aW9ucyAtIEBkZXByZWNhdGVkIHVzZSB3aXRoT3B0aW9ucyBtZXRob2QgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":35,"slug":"from-dynamic-http-requests","name":"from_dynamic_http_requests","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"requestFactory","type":[{"name":"NextRequestFactory","namespace":"Flow\\ETL\\Adapter\\Http\\DynamicExtractor","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PsrHttpClientDynamicExtractor","namespace":"Flow\\ETL\\Adapter\\Http","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":53,"slug":"from-static-http-requests","name":"from_static_http_requests","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"requests","type":[{"name":"iterable","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PsrHttpClientStaticExtractor","namespace":"Flow\\ETL\\Adapter\\Http","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpdGVyYWJsZTxSZXF1ZXN0SW50ZXJmYWNlPiAkcmVxdWVzdHMKICov"},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":68,"slug":"from-http-paginated","name":"from_http_paginated","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"request","type":[{"name":"RequestInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"paginator","type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PsrHttpClientPaginatedExtractor","namespace":"Flow\\ETL\\Adapter\\Http","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":84,"slug":"http-pagination-page-number","name":"http_pagination_page_number","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"inject","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start_page","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"page_size","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"size_option","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"inject_on_first_request","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"records_path","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":104,"slug":"http-pagination-offset","name":"http_pagination_offset","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"offset_option","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit_option","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start_offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"total_path","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"inject_on_first_request","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":124,"slug":"http-pagination-cursor","name":"http_pagination_cursor","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"cursor_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"inject","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":140,"slug":"http-pagination-next-url","name":"http_pagination_next_url","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":155,"slug":"http-pagination-link-header","name":"http_pagination_link_header","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"rel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'next'"},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":164,"slug":"http-pagination-last-record-cursor","name":"http_pagination_last_record_cursor","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"record_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"inject","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":180,"slug":"http-request-option-query","name":"http_request_option_query","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":186,"slug":"http-request-option-header","name":"http_request_option_header","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":192,"slug":"http-request-option-body","name":"http_request_option_body","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stream_factory","type":[{"name":"StreamFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":198,"slug":"http-request-option-uri","name":"http_request_option_uri","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":204,"slug":"http-stop-when-path-missing","name":"http_stop_when_path_missing","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":210,"slug":"http-stop-when-empty-path","name":"http_stop_when_empty_path","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":216,"slug":"http-stop-when-flag-false","name":"http_stop_when_flag_false","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":222,"slug":"http-stop-when-flag-true","name":"http_stop_when_flag_true","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":228,"slug":"http-stop-when-total-reached","name":"http_stop_when_total_reached","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"total_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":234,"slug":"http-stop-when-max-pages","name":"http_stop_when_max_pages","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"pages","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":240,"slug":"http-stop-when-max-results","name":"http_stop_when_max_results","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"count","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":32,"slug":"from-json","name":"from_json","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pointer","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonExtractor","namespace":"Flow\\ETL\\Adapter\\JSON\\JSONMachine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"json"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aCAtIHN0cmluZyBpcyBpbnRlcm5hbGx5IHR1cm5lZCBpbnRvIHN0cmVhbQogKiBAcGFyYW0gP3N0cmluZyAkcG9pbnRlciAtIGlmIHlvdSB3YW50IHRvIGl0ZXJhdGUgb25seSByZXN1bHRzIG9mIGEgc3VidHJlZSwgdXNlIGEgcG9pbnRlciwgcmVhZCBtb3JlIGF0IGh0dHBzOi8vZ2l0aHViLmNvbS9oYWxheGEvanNvbi1tYWNoaW5lI3BhcnNpbmctYS1zdWJ0cmVlIC0gQGRlcHJlY2F0ZSB1c2Ugd2l0aFBvaW50ZXIgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIG51bGx8U2NoZW1hICRzY2hlbWEgLSBlbmZvcmNlIHNjaGVtYSBvbiB0aGUgZXh0cmFjdGVkIGRhdGEgLSBAZGVwcmVjYXRlIHVzZSB3aXRoU2NoZW1hIG1ldGhvZCBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":58,"slug":"from-json-lines","name":"from_json_lines","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonExtractor","namespace":"Flow\\ETL\\Adapter\\JSON\\JSONMachine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"jsonl"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFVzZWQgdG8gcmVhZCBmcm9tIGEgSlNPTiBsaW5lcyBodHRwczovL2pzb25saW5lcy5vcmcvIGZvcm1hdHRlZCBmaWxlLgogKgogKiBAcGFyYW0gUGF0aHxzdHJpbmcgJHBhdGggLSBzdHJpbmcgaXMgaW50ZXJuYWxseSB0dXJuZWQgaW50byBzdHJlYW0KICov"},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":72,"slug":"to-json","name":"to_json","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"4194304"},{"name":"date_time_format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d\\\\TH:i:sP'"},{"name":"put_rows_in_new_lines","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonLoader","namespace":"Flow\\ETL\\Adapter\\JSON","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gaW50ICRmbGFncyAtIFBIUCBKU09OIEZsYWdzIC0gQGRlcHJlY2F0ZSB1c2Ugd2l0aEZsYWdzIG1ldGhvZCBpbnN0ZWFkCiAqIEBwYXJhbSBzdHJpbmcgJGRhdGVfdGltZV9mb3JtYXQgLSBmb3JtYXQgZm9yIERhdGVUaW1lSW50ZXJmYWNlOjpmb3JtYXQoKSAtIEBkZXByZWNhdGUgdXNlIHdpdGhEYXRlVGltZUZvcm1hdCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gYm9vbCAkcHV0X3Jvd3NfaW5fbmV3X2xpbmVzIC0gaWYgeW91IHdhbnQgdG8gcHV0IGVhY2ggcm93IGluIGEgbmV3IGxpbmUgLSBAZGVwcmVjYXRlIHVzZSB3aXRoUm93c0luTmV3TGluZXMgbWV0aG9kIGluc3RlYWQKICoKICogQHJldHVybiBKc29uTG9hZGVyCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":93,"slug":"to-json-lines","name":"to_json_lines","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonLoader","namespace":"Flow\\ETL\\Adapter\\JSON","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFVzZWQgdG8gd3JpdGUgdG8gYSBKU09OIGxpbmVzIGh0dHBzOi8vanNvbmxpbmVzLm9yZy8gZm9ybWF0dGVkIGZpbGUuCiAqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKgogKiBAcmV0dXJuIEpzb25Mb2FkZXIKICov"},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":107,"slug":"schema-from-json-schema","name":"schema_from_json_schema","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"json_schema","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"request_factory","type":[{"name":"RequestFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBKU09OIFNjaGVtYSAoaHR0cHM6Ly9qc29uLXNjaGVtYS5vcmcpIGRvY3VtZW50IGludG8gYSBGbG93IFNjaGVtYS4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fFBhdGh8c3RyaW5nICRqc29uX3NjaGVtYSAtIGRlY29kZWQgZG9jdW1lbnQsIHJhdyBKU09OIGRvY3VtZW50IG9yIGEgcGF0aCB0byBhIHNjaGVtYSBmaWxlCiAqIEBwYXJhbSBudWxsfENsaWVudEludGVyZmFjZSAkY2xpZW50IC0gUFNSLTE4IGh0dHAgY2xpZW50LCByZXF1aXJlZCB0byByZXNvbHZlIHJlbW90ZSBodHRwKHMpIHJlZmVyZW5jZXMKICogQHBhcmFtIG51bGx8UmVxdWVzdEZhY3RvcnlJbnRlcmZhY2UgJHJlcXVlc3RfZmFjdG9yeSAtIFBTUi0xNyByZXF1ZXN0IGZhY3RvcnksIHJlcXVpcmVkIHRvIHJlc29sdmUgcmVtb3RlIGh0dHAocykgcmVmZXJlbmNlcwogKiBAcGFyYW0gRmlsZXN5c3RlbSAkZmlsZXN5c3RlbSAtIGZpbGVzeXN0ZW0gdXNlZCB0byByZWFkIGxvY2FsIHNjaGVtYSByZWZlcmVuY2VzCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":122,"slug":"schema-to-json-schema","name":"schema_to_json_schema","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBGbG93IFNjaGVtYSBpbnRvIGEgSlNPTiBTY2hlbWEgKGh0dHBzOi8vanNvbi1zY2hlbWEub3JnLCBkcmFmdCAyMDIwLTEyKSBkb2N1bWVudC4KICoKICogQHJldHVybiBhcnJheTxzdHJpbmcsIG1peGVkPgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":36,"slug":"from-parquet","name":"from_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Parquet","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Parquet\\Options::..."},{"name":"byte_order","type":[{"name":"ByteOrder","namespace":"Flow\\Parquet\\Binary","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Parquet\\Binary\\ByteOrder::..."},{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"engine","type":[{"name":"ParquetEngine","namespace":"Flow\\Parquet","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ParquetExtractor","namespace":"Flow\\ETL\\Adapter\\Parquet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"parquet"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gYXJyYXk8c3RyaW5nPiAkY29sdW1ucyAtIGxpc3Qgb2YgY29sdW1ucyB0byByZWFkIGZyb20gcGFycXVldCBmaWxlIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoQ29sdW1uc2AgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIE9wdGlvbnMgJG9wdGlvbnMgLSBAZGVwcmVjYXRlZCB1c2UgYHdpdGhPcHRpb25zYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gQnl0ZU9yZGVyICRieXRlX29yZGVyIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoQnl0ZU9yZGVyYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxpbnQgJG9mZnNldCAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aE9mZnNldGAgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":69,"slug":"to-parquet","name":"to_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Parquet","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"compressions","type":[{"name":"Compressions","namespace":"Flow\\Parquet\\ParquetFile","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Parquet\\ParquetFile\\Compressions::..."},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"engine","type":[{"name":"ParquetEngine","namespace":"Flow\\Parquet","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ParquetLoader","namespace":"Flow\\ETL\\Adapter\\Parquet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"LOADER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"parquet"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gbnVsbHxPcHRpb25zICRvcHRpb25zIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoT3B0aW9uc2AgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIENvbXByZXNzaW9ucyAkY29tcHJlc3Npb25zIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoQ29tcHJlc3Npb25zYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxTY2hlbWEgJHNjaGVtYSAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aFNjaGVtYWAgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":100,"slug":"array-to-generator","name":"array_to_generator","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Generator","namespace":"","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBhcnJheTxUPiAkZGF0YQogKgogKiBAcmV0dXJuIFxHZW5lcmF0b3I8VD4KICov"},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":111,"slug":"empty-generator","name":"empty_generator","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[],"return_type":[{"name":"Generator","namespace":"","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBkZXByZWNhdGVkIHVzZSBGbG93XFBhcnF1ZXRcZW1wdHlfZ2VuZXJhdG9yKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":117,"slug":"schema-to-parquet","name":"schema_to_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\Parquet\\ParquetFile","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":123,"slug":"schema-from-parquet","name":"schema_from_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\Parquet\\ParquetFile","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":39,"slug":"from-pgsql-cursor","name":"from_pgsql_cursor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSqlCursorExtractor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgY3Vyc29yIGV4dHJhY3RvciB1c2luZyBzZXJ2ZXItc2lkZSBjdXJzb3JzIGZvciBtZW1vcnktZWZmaWNpZW50IGV4dHJhY3Rpb24uCiAqCiAqIFVzZXMgREVDTEFSRSBDVVJTT1IgKyBGRVRDSCB0byBzdHJlYW0gZGF0YSB3aXRob3V0IGxvYWRpbmcgZW50aXJlIHJlc3VsdCBzZXQgaW50byBtZW1vcnkuCiAqIFRoaXMgaXMgdGhlIG9ubHkgd2F5IHRvIGFjaGlldmUgdHJ1ZSBsb3cgbWVtb3J5IGV4dHJhY3Rpb24gd2l0aCBQSFAncyBleHQtcGdzcWwuCiAqCiAqIE5vdGU6IFJlcXVpcmVzIGEgdHJhbnNhY3Rpb24gY29udGV4dCAoYXV0by1zdGFydGVkIGlmIG5vdCBpbiBvbmUpLgogKgogKiBAcGFyYW0gQ2xpZW50ICRjbGllbnQgUG9zdGdyZVNRTCBjbGllbnQKICogQHBhcmFtIFNxbHxzdHJpbmcgJHF1ZXJ5IFNRTCBxdWVyeSB0byBleGVjdXRlICh3cmFwcGVkIGluIERFQ0xBUkUgQ1VSU09SKQogKiBAcGFyYW0gbGlzdDxtaXhlZD4gJHBhcmFtZXRlcnMgVmFsdWVzIGJvdW5kIGJ5IHBvc2l0aW9uIHRvICQxLCAkMiwgLi4uIHBsYWNlaG9sZGVyczsgd3JhcCB3aXRoIHtAc2VlIFxGbG93XFBvc3RncmVTcWxcRFNMXHR5cGVkKCl9IHRvIGZvcmNlIGEgc3BlY2lmaWMgUG9zdGdyZVNRTCB0eXBlCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":55,"slug":"from-pgsql-limit-offset","name":"from_pgsql_limit_offset","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSqlLimitOffsetExtractor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgZXh0cmFjdG9yIHVzaW5nIExJTUlUL09GRlNFVCBwYWdpbmF0aW9uLgogKgogKiBTdWl0YWJsZSBmb3Igc21hbGxlciBkYXRhc2V0cy4gRm9yIGxhcmdlIGRhdGFzZXRzLCBjb25zaWRlciB1c2luZyBrZXlzZXQgcGFnaW5hdGlvbgogKiAoZnJvbV9wZ3NxbF9rZXlfc2V0KSB3aGljaCBpcyBtb3JlIGVmZmljaWVudC4KICoKICogQHBhcmFtIENsaWVudCAkY2xpZW50IFBvc3RncmVTUUwgY2xpZW50CiAqIEBwYXJhbSBTcWx8c3RyaW5nICRxdWVyeSBTUUwgcXVlcnkgdG8gZXhlY3V0ZSAobXVzdCBoYXZlIE9SREVSIEJZIGNsYXVzZSkKICogQHBhcmFtIGxpc3Q8bWl4ZWQ+ICRwYXJhbWV0ZXJzIFZhbHVlcyBib3VuZCBieSBwb3NpdGlvbiB0byAkMSwgJDIsIC4uLiBwbGFjZWhvbGRlcnM7IHdyYXAgd2l0aCB7QHNlZSBcRmxvd1xQb3N0Z3JlU3FsXERTTFx0eXBlZCgpfSB0byBmb3JjZSBhIHNwZWNpZmljIFBvc3RncmVTUUwgdHlwZQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":75,"slug":"from-pgsql-key-set","name":"from_pgsql_key_set","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keySet","type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSqlKeySetExtractor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgZXh0cmFjdG9yIHVzaW5nIGtleXNldCAoY3Vyc29yLWJhc2VkKSBwYWdpbmF0aW9uLgogKgogKiBNb3JlIGVmZmljaWVudCB0aGFuIExJTUlUL09GRlNFVCBmb3IgbGFyZ2UgZGF0YXNldHMgLSB1c2VzIGluZGV4ZWQgV0hFUkUgY29uZGl0aW9ucwogKiBpbnN0ZWFkIG9mIHNraXBwaW5nIHJvd3MuCiAqCiAqIEBwYXJhbSBDbGllbnQgJGNsaWVudCBQb3N0Z3JlU1FMIGNsaWVudAogKiBAcGFyYW0gU3FsfHN0cmluZyAkcXVlcnkgU1FMIHF1ZXJ5IHRvIGV4ZWN1dGUgKE9SREVSIEJZIG9wdGlvbmFsOyB3aGVuIHByZXNlbnQgaXQgbXVzdCBlcXVhbCB0aGUga2V5czsgbm8gTElNSVQvT0ZGU0VUOyBrZXlzIGluZGV4ZWQsIG5vbi1udWxsLCB1bmlxdWUpCiAqIEBwYXJhbSBLZXlTZXQgJGtleVNldCBDb2x1bW5zIHRvIHVzZSBmb3Iga2V5c2V0IHBhZ2luYXRpb24KICogQHBhcmFtIGxpc3Q8bWl4ZWQ+ICRwYXJhbWV0ZXJzIFZhbHVlcyBib3VuZCBieSBwb3NpdGlvbiB0byAkMSwgJDIsIC4uLiBwbGFjZWhvbGRlcnM7IHdyYXAgd2l0aCB7QHNlZSBcRmxvd1xQb3N0Z3JlU3FsXERTTFx0eXBlZCgpfSB0byBmb3JjZSBhIHNwZWNpZmljIFBvc3RncmVTUUwgdHlwZQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":85,"slug":"pgsql-pagination-key-asc","name":"pgsql_pagination_key_asc","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":91,"slug":"pgsql-pagination-key-desc","name":"pgsql_pagination_key_desc","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":97,"slug":"pgsql-pagination-key-set","name":"pgsql_pagination_key_set","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"keys","type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":103,"slug":"to-pgsql-table","name":"to_pgsql_table","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PostgreSqlLoader","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":112,"slug":"to-pgsql-transaction","name":"to_pgsql_transaction","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sinks","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Transactional","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyaXRlIGV2ZXJ5IHNpbmsgd2l0aGluIFBvc3RncmVTUUwgdHJhbnNhY3Rpb25zLgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":126,"slug":"pgsql-insert-options","name":"pgsql_insert_options","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"skipConflicts","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"conflictColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"conflictConstraint","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"updateColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"InsertOptions","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\LoaderOptions","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBpbnNlcnQgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBsb2FkZXIuCiAqCiAqIEBwYXJhbSBib29sICRza2lwQ29uZmxpY3RzIElmIHRydWUsIHVzZSBPTiBDT05GTElDVCBETyBOT1RISU5HCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGNvbmZsaWN0Q29sdW1ucyBDb2x1bW4gbmFtZXMgZm9yIE9OIENPTkZMSUNUIChjb2x1bW5zKQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGNvbmZsaWN0Q29uc3RyYWludCBDb25zdHJhaW50IG5hbWUgZm9yIE9OIENPTkZMSUNUIE9OIENPTlNUUkFJTlQKICogQHBhcmFtIGxpc3Q8c3RyaW5nPiAkdXBkYXRlQ29sdW1ucyBDb2x1bW5zIHRvIHVwZGF0ZSBvbiBjb25mbGljdCAoZW1wdHkgPSBhbGwgbm9uLWtleSBjb2x1bW5zKQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":141,"slug":"pgsql-update-options","name":"pgsql_update_options","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"primaryKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UpdateOptions","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\LoaderOptions","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB1cGRhdGUgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBsb2FkZXIuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHByaW1hcnlLZXlzIENvbHVtbnMgdG8gdXNlIGluIFdIRVJFIGNsYXVzZSBmb3IgbWF0Y2hpbmcgcm93cwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":152,"slug":"pgsql-delete-options","name":"pgsql_delete_options","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"primaryKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DeleteOptions","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\LoaderOptions","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBkZWxldGUgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBsb2FkZXIuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHByaW1hcnlLZXlzIENvbHVtbnMgdG8gdXNlIGluIFdIRVJFIGNsYXVzZSBmb3IgbWF0Y2hpbmcgcm93cwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":164,"slug":"to-pgsql-schema-table","name":"to_pgsql_schema_table","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tableName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"databaseSchema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'public'"},{"name":"typesMap","type":[{"name":"EntryTypesMap","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"options","type":[{"name":"TableOptions","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Table","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBGbG93IFNjaGVtYSBpbnRvIGEgUG9zdGdyZVNRTCB0YWJsZSBkZWZpbml0aW9uLgogKgogKiBAcGFyYW0gc3RyaW5nICRkYXRhYmFzZVNjaGVtYSBQb3N0Z3JlU1FMIHNjaGVtYSAobmFtZXNwYWNlKSB0aGUgdGFibGUgYmVsb25ncyB0bwogKiBAcGFyYW0gP1RhYmxlT3B0aW9ucyAkb3B0aW9ucyB0YWJsZS1sZXZlbCBvcHRpb25zIHRoZSBGbG93IFNjaGVtYSBjYW5ub3QgZXhwcmVzcyAoZS5nLiBVTkxPR0dFRCkKICov"},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":178,"slug":"pgsql-table-to-flow-schema","name":"pgsql_table_to_flow_schema","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"table","type":[{"name":"Table","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typesMap","type":[{"name":"EntryTypesMap","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBQb3N0Z3JlU1FMIHRhYmxlIGRlZmluaXRpb24gaW50byBhIEZsb3cgU2NoZW1hLgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":184,"slug":"pgsql-schema-sort-by-type","name":"pgsql_schema_sort_by_type","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"typesMap","type":[{"name":"EntryTypesMap","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TypeStrategy","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Schema\\SortingStrategy","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":15,"slug":"to-seal-upsert","name":"to_seal_upsert","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"engine","type":[{"name":"EngineInterface","namespace":"CmsIg\\Seal","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"index","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SealLoader","namespace":"Flow\\ETL\\Adapter\\Seal","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":21,"slug":"to-seal-delete","name":"to_seal_delete","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"engine","type":[{"name":"EngineInterface","namespace":"CmsIg\\Seal","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"index","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SealLoader","namespace":"Flow\\ETL\\Adapter\\Seal","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":27,"slug":"to-seal-schema","name":"to_seal_schema","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"index_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"identifier","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Schema","namespace":"CmsIg\\Seal\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":33,"slug":"seal-schema-to-flow","name":"seal_schema_to_flow","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"CmsIg\\Seal\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-text\/src\/Flow\/ETL\/Adapter\/Text\/functions.php","start_line_in_file":21,"slug":"from-text","name":"from_text","namespace":"Flow\\ETL\\Adapter\\Text","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"TextExtractor","namespace":"Flow\\ETL\\Adapter\\Text","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TEXT","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-text\/src\/Flow\/ETL\/Adapter\/Text\/functions.php","start_line_in_file":31,"slug":"to-text","name":"to_text","namespace":"Flow\\ETL\\Adapter\\Text","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"new_line_separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\n'"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"TextLoader","namespace":"Flow\\ETL\\Adapter\\Text","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TEXT","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gc3RyaW5nICRuZXdfbGluZV9zZXBhcmF0b3IgLSBkZWZhdWx0IFBIUF9FT0wgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aE5ld0xpbmVTZXBhcmF0b3IgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-xml\/src\/Flow\/ETL\/Adapter\/XML\/functions.php","start_line_in_file":38,"slug":"from-xml","name":"from_xml","namespace":"Flow\\ETL\\Adapter\\XML","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"xml_node_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"''"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"XMLParserExtractor","namespace":"Flow\\ETL\\Adapter\\XML","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"XML","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"xml"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqICBJbiBvcmRlciB0byBpdGVyYXRlIG9ubHkgb3ZlciA8ZWxlbWVudD4gbm9kZXMgdXNlIGBmcm9tX3htbCgkZmlsZSktPndpdGhYTUxOb2RlUGF0aCgncm9vdC9lbGVtZW50cy9lbGVtZW50JylgLgogKgogKiAgPHJvb3Q+CiAqICAgIDxlbGVtZW50cz4KICogICAgICA8ZWxlbWVudD48L2VsZW1lbnQ+CiAqICAgICAgPGVsZW1lbnQ+PC9lbGVtZW50PgogKiAgICA8ZWxlbWVudHM+CiAqICA8L3Jvb3Q+CiAqCiAqICBYTUwgTm9kZSBQYXRoIGRvZXMgbm90IHN1cHBvcnQgYXR0cmlidXRlcyBhbmQgaXQncyBub3QgeHBhdGgsIGl0IGlzIGp1c3QgYSBzZXF1ZW5jZQogKiAgb2Ygbm9kZSBuYW1lcyBzZXBhcmF0ZWQgd2l0aCBzbGFzaC4KICoKICogQHBhcmFtIFBhdGh8c3RyaW5nICRwYXRoCiAqIEBwYXJhbSBzdHJpbmcgJHhtbF9ub2RlX3BhdGggLSBAZGVwcmVjYXRlZCB1c2UgYGZyb21feG1sKCRmaWxlKS0+d2l0aFhNTE5vZGVQYXRoKCR4bWxOb2RlUGF0aClgIG1ldGhvZCBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-xml\/src\/Flow\/ETL\/Adapter\/XML\/functions.php","start_line_in_file":57,"slug":"to-xml","name":"to_xml","namespace":"Flow\\ETL\\Adapter\\XML","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"root_element_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'rows'"},{"name":"row_element_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'row'"},{"name":"attribute_prefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'_'"},{"name":"date_time_format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d\\\\TH:i:s.uP'"},{"name":"xml_writer","type":[{"name":"XMLWriter","namespace":"Flow\\ETL\\Adapter\\XML","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Adapter\\XML\\XMLWriter\\StringXMLWriter::..."},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"XMLLoader","namespace":"Flow\\ETL\\Adapter\\XML\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"XML","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gc3RyaW5nICRyb290X2VsZW1lbnRfbmFtZSAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aFJvb3RFbGVtZW50TmFtZSgpYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRyb3dfZWxlbWVudF9uYW1lIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoUm93RWxlbWVudE5hbWUoKWAgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIHN0cmluZyAkYXR0cmlidXRlX3ByZWZpeCAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aEF0dHJpYnV0ZVByZWZpeCgpYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRkYXRlX3RpbWVfZm9ybWF0IC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoRGF0ZVRpbWVGb3JtYXQoKWAgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIFhNTFdyaXRlciAkeG1sX3dyaXRlcgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":32,"slug":"mount","name":"mount","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Mount","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":38,"slug":"partition","name":"partition","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"value","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Partition","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":44,"slug":"partitions","name":"partitions","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"partition","type":[{"name":"Partition","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Partitions","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":63,"slug":"path","name":"path","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Path","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhdGggc3VwcG9ydHMgZ2xvYiBwYXR0ZXJucy4KICogRXhhbXBsZXM6CiAqICAtIHBhdGgoJyouY3N2JykgLSBhbnkgY3N2IGZpbGUgaW4gY3VycmVudCBkaXJlY3RvcnkKICogIC0gcGF0aCgnLyoqIC8gKi5jc3YnKSAtIGFueSBjc3YgZmlsZSBpbiBhbnkgc3ViZGlyZWN0b3J5IChyZW1vdmUgZW1wdHkgc3BhY2VzKQogKiAgLSBwYXRoKCcvZGlyL3BhcnRpdGlvbj0qIC8qLnBhcnF1ZXQnKSAtIGFueSBwYXJxdWV0IGZpbGUgaW4gZ2l2ZW4gcGFydGl0aW9uIGRpcmVjdG9yeS4KICoKICogR2xvYiBwYXR0ZXJuIGlzIGFsc28gc3VwcG9ydGVkIGJ5IHJlbW90ZSBmaWxlc3lzdGVtcyBsaWtlIEF6dXJlCiAqCiAqICAtIHBhdGgoJ2F6dXJlLWJsb2I6Ly9kaXJlY3RvcnkvKi5jc3YnKSAtIGFueSBjc3YgZmlsZSBpbiBnaXZlbiBkaXJlY3RvcnkKICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbnVsbHxib29sfGZsb2F0fGludHxzdHJpbmd8XFVuaXRFbnVtPnxQYXRoXE9wdGlvbnMgJG9wdGlvbnMKICov"},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":74,"slug":"path-real","name":"path_real","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJlc29sdmUgcmVhbCBwYXRoIGZyb20gZ2l2ZW4gcGF0aC4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbnVsbHxib29sfGZsb2F0fGludHxzdHJpbmd8XFVuaXRFbnVtPiAkb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":80,"slug":"native-local-filesystem","name":"native_local_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'file'"}],"return_type":[{"name":"NativeLocalFilesystem","namespace":"Flow\\Filesystem\\Local","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":90,"slug":"stdout-filesystem","name":"stdout_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'stdout'"}],"return_type":[{"name":"StdOutFilesystem","namespace":"Flow\\Filesystem\\Local","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyaXRlLW9ubHkgZmlsZXN5c3RlbSB1c2VmdWwgd2hlbiB3ZSBqdXN0IHdhbnQgdG8gd3JpdGUgdGhlIG91dHB1dCB0byBzdGRvdXQuCiAqIFRoZSBtYWluIHVzZSBjYXNlIGlzIGZvciBzdHJlYW1pbmcgZGF0YXNldHMgb3ZlciBodHRwLgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":99,"slug":"memory-filesystem","name":"memory_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'memory'"}],"return_type":[{"name":"MemoryFilesystem","namespace":"Flow\\Filesystem\\Local","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBtZW1vcnkgZmlsZXN5c3RlbSBhbmQgd3JpdGVzIGRhdGEgdG8gaXQgaW4gbWVtb3J5LgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":110,"slug":"fstab","name":"fstab","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"filesystems","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"FilesystemTable","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBmaWxlc3lzdGVtIHRhYmxlIHdpdGggZ2l2ZW4gZmlsZXN5c3RlbXMuCiAqIEZpbGVzeXN0ZW1zIGNhbiBiZSBhbHNvIG1vdW50ZWQgbGF0ZXIuCiAqIElmIG5vIGZpbGVzeXN0ZW1zIGFyZSBwcm92aWRlZCwgbG9jYWwgZmlsZXN5c3RlbSBpcyBtb3VudGVkLgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":126,"slug":"traceable-filesystem","name":"traceable_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"telemetryConfig","type":[{"name":"FilesystemTelemetryConfig","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TraceableFilesystem","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYSBmaWxlc3lzdGVtIHdpdGggdGVsZW1ldHJ5IHRyYWNpbmcgc3VwcG9ydC4KICogQWxsIGZpbGVzeXN0ZW0gYW5kIHN0cmVhbSBvcGVyYXRpb25zIHdpbGwgYmUgdHJhY2VkIGFjY29yZGluZyB0byB0aGUgY29uZmlndXJhdGlvbi4KICov"},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":135,"slug":"filesystem-telemetry-config","name":"filesystem_telemetry_config","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"telemetry","type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"FilesystemTelemetryOptions","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FilesystemTelemetryConfig","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRlbGVtZXRyeSBjb25maWd1cmF0aW9uIGZvciB0aGUgZmlsZXN5c3RlbS4KICov"},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":150,"slug":"filesystem-telemetry-options","name":"filesystem_telemetry_options","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"trace_streams","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"collect_metrics","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"FilesystemTelemetryOptions","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBvcHRpb25zIGZvciBmaWxlc3lzdGVtIHRlbGVtZXRyeS4KICoKICogQHBhcmFtIGJvb2wgJHRyYWNlX3N0cmVhbXMgQ3JlYXRlIGEgc2luZ2xlIHNwYW4gcGVyIHN0cmVhbSBsaWZlY3ljbGUgKGRlZmF1bHQ6IE9OKQogKiBAcGFyYW0gYm9vbCAkY29sbGVjdF9tZXRyaWNzIENvbGxlY3QgbWV0cmljcyBmb3IgYnl0ZXMvb3BlcmF0aW9uIGNvdW50cyAoZGVmYXVsdDogT04pCiAqLw=="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":163,"slug":"file-copy","name":"file_copy","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"table","type":[{"name":"FilesystemTable","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"OperationOptions","namespace":"Flow\\Filesystem\\Operations","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Copy","namespace":"Flow\\Filesystem\\Operations","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvcHkgYSBmaWxlIGZyb20gb25lIHBhdGggdG8gYW5vdGhlciwgYWNyb3NzIGFueSBmaWxlc3lzdGVtcyBtb3VudGVkIGluIHRoZSB0YWJsZS4KICogQWx3YXlzIHN0cmVhbXMgYnl0ZXM7IHNhbWUtZmlsZXN5c3RlbSBjb3BpZXMgZG8gbm90IHVzZSBzZXJ2ZXItc2lkZSBvcHRpbWl6YXRpb25zCiAqIGJlY2F1c2UgYEZpbGVzeXN0ZW06Om12YCBpcyBhIG1vdmUsIG5vdCBhIGNvcHkuCiAqLw=="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":174,"slug":"file-move","name":"file_move","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"table","type":[{"name":"FilesystemTable","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"OperationOptions","namespace":"Flow\\Filesystem\\Operations","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Move","namespace":"Flow\\Filesystem\\Operations","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE1vdmUgYSBmaWxlIGZyb20gb25lIHBhdGggdG8gYW5vdGhlciwgYWNyb3NzIGFueSBmaWxlc3lzdGVtcyBtb3VudGVkIGluIHRoZSB0YWJsZS4KICogSW50cmEtZmlsZXN5c3RlbSBtb3ZlcyBkZWxlZ2F0ZSB0byBgRmlsZXN5c3RlbTo6bXZgIGZvciBzZXJ2ZXItc2lkZSBvcHRpbWl6YXRpb25zOwogKiBjcm9zcy1maWxlc3lzdGVtIG1vdmVzIHN0cmVhbS1jb3B5IHRoZW4gcmVtb3ZlIHRoZSBzb3VyY2UgKG5vbi1hdG9taWMpLgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":185,"slug":"operation-options","name":"operation_options","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"chunkSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"8192"}],"return_type":[{"name":"OperationOptions","namespace":"Flow\\Filesystem\\Operations","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE9wdGlvbnMgc2hhcmVkIGJ5IGZpbGVzeXN0ZW0gb3BlcmF0aW9ucy4KICoKICogQHBhcmFtIGludCAkY2h1bmtTaXplIE51bWJlciBvZiBieXRlcyByZWFkL3dyaXR0ZW4gcGVyIGl0ZXJhdGlvbiB3aGVuIHN0cmVhbWluZyBhY3Jvc3MgZmlsZXN5c3RlbXMgKGRlZmF1bHQ6IDgxOTIpCiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":65,"slug":"type-structure","name":"type_structure","namespace":"Flow\\Types\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"StructureType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIFN0cnVjdHVyZUVsZW1lbnQ8VD58VHlwZTxUPj4gJGVsZW1lbnRzCiAqCiAqIEByZXR1cm4gU3RydWN0dXJlVHlwZTxhcnJheTxhcnJheS1rZXksIFQ+PgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":80,"slug":"structure-element","name":"structure_element","namespace":"Flow\\Types\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"optional","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"StructureElement","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqIEB0ZW1wbGF0ZSBUT3B0aW9uYWwgb2YgYm9vbAogKgogKiBAcGFyYW0gVHlwZTxUPiAkdHlwZQogKiBAcGFyYW0gVE9wdGlvbmFsICRvcHRpb25hbAogKgogKiBAcmV0dXJuIFN0cnVjdHVyZUVsZW1lbnQ8VCwgVE9wdGlvbmFsPgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":95,"slug":"type-union","name":"type_union","namespace":"Flow\\Types\\DSL","parameters":[{"name":"first","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"second","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"UnionType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICRmaXJzdAogKiBAcGFyYW0gVHlwZTxUPiAkc2Vjb25kCiAqIEBwYXJhbSBUeXBlPFQ+IC4uLiR0eXBlcwogKgogKiBAcmV0dXJuIFVuaW9uVHlwZTxULCBUPgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":116,"slug":"type-intersection","name":"type_intersection","namespace":"Flow\\Types\\DSL","parameters":[{"name":"first","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"second","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"IntersectionType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICRmaXJzdAogKiBAcGFyYW0gVHlwZTxUPiAkc2Vjb25kCiAqIEBwYXJhbSBUeXBlPFQ+IC4uLiR0eXBlcwogKgogKiBAcmV0dXJuIEludGVyc2VjdGlvblR5cGU8VCwgVD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":128,"slug":"type-numeric-string","name":"type_numeric_string","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"NumericStringType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":141,"slug":"type-optional","name":"type_optional","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OptionalType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqCiAqIEByZXR1cm4gT3B0aW9uYWxUeXBlPFQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":152,"slug":"type-from-array","name":"type_from_array","namespace":"Flow\\Types\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPiAkZGF0YQogKgogKiBAcmV0dXJuIFR5cGU8bWl4ZWQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":163,"slug":"type-is-nullable","name":"type_is_nullable","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":179,"slug":"type-bare","name":"type_bare","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0cmlwIGV4YWN0bHkgb25lIGxldmVsIG9mIG51bGxhYmlsaXR5LCB3aGljaGV2ZXIgb2YgdGhlIHR3byBzcGVsbGluZ3MgY2FycmllcyBpdAogKiAoT3B0aW9uYWxUeXBlLCBvciBhIFVuaW9uVHlwZSBjb250YWluaW5nIE51bGxUeXBlKS4gVG90YWw6IGEgTk9UIE5VTEwgdHlwZSBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCiAqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqCiAqIEByZXR1cm4gVHlwZTxtaXhlZD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":189,"slug":"type-equals","name":"type_equals","namespace":"Flow\\Types\\DSL","parameters":[{"name":"left","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAkbGVmdAogKiBAcGFyYW0gVHlwZTxtaXhlZD4gJHJpZ2h0CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":202,"slug":"types","name":"types","namespace":"Flow\\Types\\DSL","parameters":[{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Types","namespace":"Flow\\Types\\Type","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+IC4uLiR0eXBlcwogKgogKiBAcmV0dXJuIFR5cGVzPFQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":215,"slug":"type-list","name":"type_list","namespace":"Flow\\Types\\DSL","parameters":[{"name":"element","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ListType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICRlbGVtZW50CiAqCiAqIEByZXR1cm4gTGlzdFR5cGU8VD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":230,"slug":"type-map","name":"type_map","namespace":"Flow\\Types\\DSL","parameters":[{"name":"key_type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"value_type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MapType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUS2V5IG9mIGFycmF5LWtleQogKiBAdGVtcGxhdGUgVFZhbHVlCiAqCiAqIEBwYXJhbSBUeXBlPFRLZXk+ICRrZXlfdHlwZQogKiBAcGFyYW0gVHlwZTxUVmFsdWU+ICR2YWx1ZV90eXBlCiAqCiAqIEByZXR1cm4gTWFwVHlwZTxUS2V5LCBUVmFsdWU+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":236,"slug":"type-json","name":"type_json","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"JsonType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":242,"slug":"type-datetime","name":"type_datetime","namespace":"Flow\\Types\\DSL","parameters":[{"name":"zone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'UTC'"}],"return_type":[{"name":"DateTimeType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":248,"slug":"type-date","name":"type_date","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"DateType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":254,"slug":"type-time","name":"type_time","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"TimeType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":260,"slug":"type-time-zone","name":"type_time_zone","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"TimeZoneType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":266,"slug":"type-xml","name":"type_xml","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"XMLType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":272,"slug":"type-xml-element","name":"type_xml_element","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"XMLElementType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":278,"slug":"type-uuid","name":"type_uuid","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"UuidType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":284,"slug":"type-integer","name":"type_integer","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"IntegerType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":290,"slug":"type-string","name":"type_string","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"StringType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":296,"slug":"type-float","name":"type_float","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"FloatType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":302,"slug":"type-boolean","name":"type_boolean","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"BooleanType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":315,"slug":"type-instance-of","name":"type_instance_of","namespace":"Flow\\Types\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"InstanceOfType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICRjbGFzcwogKgogKiBAcmV0dXJuIEluc3RhbmNlT2ZUeXBlPFQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":321,"slug":"type-object","name":"type_object","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ObjectType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":327,"slug":"type-scalar","name":"type_scalar","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ScalarType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":333,"slug":"type-resource","name":"type_resource","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ResourceType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":339,"slug":"type-array","name":"type_array","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ArrayType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":345,"slug":"type-callable","name":"type_callable","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"CallableType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":351,"slug":"type-null","name":"type_null","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"NullType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":357,"slug":"type-mixed","name":"type_mixed","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"MixedType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":363,"slug":"type-positive-integer","name":"type_positive_integer","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"PositiveIntegerType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":369,"slug":"type-non-empty-string","name":"type_non_empty_string","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"NonEmptyStringType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":375,"slug":"type-empty-array","name":"type_empty_array","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"EmptyArrayType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":388,"slug":"type-enum","name":"type_enum","namespace":"Flow\\Types\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnumType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIFVuaXRFbnVtCiAqCiAqIEBwYXJhbSBjbGFzcy1zdHJpbmc8VD4gJGNsYXNzCiAqCiAqIEByZXR1cm4gRW51bVR5cGU8VD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":401,"slug":"type-literal","name":"type_literal","namespace":"Flow\\Types\\DSL","parameters":[{"name":"value","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"LiteralType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIGJvb2x8ZmxvYXR8aW50fHN0cmluZwogKgogKiBAcGFyYW0gVCAkdmFsdWUKICoKICogQHJldHVybiBMaXRlcmFsVHlwZTxUPgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":407,"slug":"type-html","name":"type_html","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"HTMLType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":413,"slug":"type-html-element","name":"type_html_element","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"HTMLElementType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":425,"slug":"type-is","name":"type_is","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typeClass","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqIEBwYXJhbSBjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+ICR0eXBlQ2xhc3MKICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":438,"slug":"type-is-any","name":"type_is_any","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typeClass","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typeClasses","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqIEBwYXJhbSBjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+ICR0eXBlQ2xhc3MKICogQHBhcmFtIGNsYXNzLXN0cmluZzxUeXBlPG1peGVkPj4gLi4uJHR5cGVDbGFzc2VzCiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":447,"slug":"get-type","name":"get_type","namespace":"Flow\\Types\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gVHlwZTxtaXhlZD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":460,"slug":"type-class-string","name":"type_class_string","namespace":"Flow\\Types\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ClassStringType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gbnVsbHxjbGFzcy1zdHJpbmc8VD4gJGNsYXNzCiAqCiAqIEByZXR1cm4gKCRjbGFzcyBpcyBudWxsID8gQ2xhc3NTdHJpbmdUeXBlPGNsYXNzLXN0cmluZz4gOiBDbGFzc1N0cmluZ1R5cGU8Y2xhc3Mtc3RyaW5nPFQ+PikKICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":466,"slug":"dom-element-to-string","name":"dom_element_to_string","namespace":"Flow\\Types\\DSL","parameters":[{"name":"element","type":[{"name":"DOMElement","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"format_output","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"preserver_white_space","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"false","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":134,"slug":"column","name":"column","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnDefinition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbHVtbiBkZWZpbml0aW9uIGZvciBDUkVBVEUgVEFCTEUuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgQ29sdW1uIG5hbWUKICogQHBhcmFtIENvbHVtblR5cGUgJHR5cGUgQ29sdW1uIGRhdGEgdHlwZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":143,"slug":"catalog","name":"catalog","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"schemas","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Catalog","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYT4gJHNjaGVtYXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":154,"slug":"primary-key","name":"primary_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"PrimaryKeyConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBSSU1BUlkgS0VZIGNvbnN0cmFpbnQuCiAqCiAqIEBwYXJhbSBzdHJpbmcgLi4uJGNvbHVtbnMgQ29sdW1ucyB0aGF0IGZvcm0gdGhlIHByaW1hcnkga2V5CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":165,"slug":"unique-constraint","name":"unique_constraint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"UniqueConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFVOSVFVRSBjb25zdHJhaW50LgogKgogKiBAcGFyYW0gc3RyaW5nIC4uLiRjb2x1bW5zIENvbHVtbnMgdGhhdCBtdXN0IGJlIHVuaXF1ZSB0b2dldGhlcgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":178,"slug":"foreign-key","name":"foreign_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceTable","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ForeignKeyConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEZPUkVJR04gS0VZIGNvbnN0cmFpbnQuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGNvbHVtbnMgTG9jYWwgY29sdW1ucwogKiBAcGFyYW0gc3RyaW5nICRyZWZlcmVuY2VUYWJsZSBSZWZlcmVuY2VkIHRhYmxlCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHJlZmVyZW5jZUNvbHVtbnMgUmVmZXJlbmNlZCBjb2x1bW5zIChkZWZhdWx0cyB0byBzYW1lIGFzICRjb2x1bW5zIGlmIGVtcHR5KQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":187,"slug":"check-constraint","name":"check_constraint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"condition","type":[{"name":"Condition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CheckConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENIRUNLIGNvbnN0cmFpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":218,"slug":"create","name":"create","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"CreateFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZhY3RvcnkgZm9yIGJ1aWxkaW5nIENSRUFURSBzdGF0ZW1lbnRzLgogKgogKiBQcm92aWRlcyBhIHVuaWZpZWQgZW50cnkgcG9pbnQgZm9yIGFsbCBDUkVBVEUgb3BlcmF0aW9uczoKICogLSBjcmVhdGUoKS0+dGFibGUoKSAtIENSRUFURSBUQUJMRQogKiAtIGNyZWF0ZSgpLT50YWJsZUFzKCkgLSBDUkVBVEUgVEFCTEUgQVMKICogLSBjcmVhdGUoKS0+aW5kZXgoKSAtIENSRUFURSBJTkRFWAogKiAtIGNyZWF0ZSgpLT52aWV3KCkgLSBDUkVBVEUgVklFVwogKiAtIGNyZWF0ZSgpLT5tYXRlcmlhbGl6ZWRWaWV3KCkgLSBDUkVBVEUgTUFURVJJQUxJWkVEIFZJRVcKICogLSBjcmVhdGUoKS0+c2VxdWVuY2UoKSAtIENSRUFURSBTRVFVRU5DRQogKiAtIGNyZWF0ZSgpLT5zY2hlbWEoKSAtIENSRUFURSBTQ0hFTUEKICogLSBjcmVhdGUoKS0+cm9sZSgpIC0gQ1JFQVRFIFJPTEUKICogLSBjcmVhdGUoKS0+ZnVuY3Rpb24oKSAtIENSRUFURSBGVU5DVElPTgogKiAtIGNyZWF0ZSgpLT5wcm9jZWR1cmUoKSAtIENSRUFURSBQUk9DRURVUkUKICogLSBjcmVhdGUoKS0+dHJpZ2dlcigpIC0gQ1JFQVRFIFRSSUdHRVIKICogLSBjcmVhdGUoKS0+cnVsZSgpIC0gQ1JFQVRFIFJVTEUKICogLSBjcmVhdGUoKS0+ZXh0ZW5zaW9uKCkgLSBDUkVBVEUgRVhURU5TSU9OCiAqIC0gY3JlYXRlKCktPmNvbXBvc2l0ZVR5cGUoKSAtIENSRUFURSBUWVBFIChjb21wb3NpdGUpCiAqIC0gY3JlYXRlKCktPmVudW1UeXBlKCkgLSBDUkVBVEUgVFlQRSAoZW51bSkKICogLSBjcmVhdGUoKS0+cmFuZ2VUeXBlKCkgLSBDUkVBVEUgVFlQRSAocmFuZ2UpCiAqIC0gY3JlYXRlKCktPmRvbWFpbigpIC0gQ1JFQVRFIERPTUFJTgogKgogKiBFeGFtcGxlOiBjcmVhdGUoKS0+dGFibGUoJ3VzZXJzJyktPmNvbHVtbnMoY29sX2RlZignaWQnLCBjb2x1bW5fdHlwZV9zZXJpYWwoKSkpCiAqIEV4YW1wbGU6IGNyZWF0ZSgpLT5pbmRleCgnaWR4X2VtYWlsJyktPm9uKCd1c2VycycpLT5jb2x1bW5zKCdlbWFpbCcpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":247,"slug":"drop","name":"drop","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"DropFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZhY3RvcnkgZm9yIGJ1aWxkaW5nIERST1Agc3RhdGVtZW50cy4KICoKICogUHJvdmlkZXMgYSB1bmlmaWVkIGVudHJ5IHBvaW50IGZvciBhbGwgRFJPUCBvcGVyYXRpb25zOgogKiAtIGRyb3AoKS0+dGFibGUoKSAtIERST1AgVEFCTEUKICogLSBkcm9wKCktPmluZGV4KCkgLSBEUk9QIElOREVYCiAqIC0gZHJvcCgpLT52aWV3KCkgLSBEUk9QIFZJRVcKICogLSBkcm9wKCktPm1hdGVyaWFsaXplZFZpZXcoKSAtIERST1AgTUFURVJJQUxJWkVEIFZJRVcKICogLSBkcm9wKCktPnNlcXVlbmNlKCkgLSBEUk9QIFNFUVVFTkNFCiAqIC0gZHJvcCgpLT5zY2hlbWEoKSAtIERST1AgU0NIRU1BCiAqIC0gZHJvcCgpLT5yb2xlKCkgLSBEUk9QIFJPTEUKICogLSBkcm9wKCktPmZ1bmN0aW9uKCkgLSBEUk9QIEZVTkNUSU9OCiAqIC0gZHJvcCgpLT5wcm9jZWR1cmUoKSAtIERST1AgUFJPQ0VEVVJFCiAqIC0gZHJvcCgpLT50cmlnZ2VyKCkgLSBEUk9QIFRSSUdHRVIKICogLSBkcm9wKCktPnJ1bGUoKSAtIERST1AgUlVMRQogKiAtIGRyb3AoKS0+ZXh0ZW5zaW9uKCkgLSBEUk9QIEVYVEVOU0lPTgogKiAtIGRyb3AoKS0+dHlwZSgpIC0gRFJPUCBUWVBFCiAqIC0gZHJvcCgpLT5kb21haW4oKSAtIERST1AgRE9NQUlOCiAqIC0gZHJvcCgpLT5vd25lZCgpIC0gRFJPUCBPV05FRAogKgogKiBFeGFtcGxlOiBkcm9wKCktPnRhYmxlKCd1c2VycycsICdvcmRlcnMnKS0+aWZFeGlzdHMoKS0+Y2FzY2FkZSgpCiAqIEV4YW1wbGU6IGRyb3AoKS0+aW5kZXgoJ2lkeF9lbWFpbCcpLT5pZkV4aXN0cygpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":281,"slug":"alter","name":"alter","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AlterFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZhY3RvcnkgZm9yIGJ1aWxkaW5nIEFMVEVSIHN0YXRlbWVudHMuCiAqCiAqIFByb3ZpZGVzIGEgdW5pZmllZCBlbnRyeSBwb2ludCBmb3IgYWxsIEFMVEVSIG9wZXJhdGlvbnM6CiAqIC0gYWx0ZXIoKS0+dGFibGUoKSAtIEFMVEVSIFRBQkxFCiAqIC0gYWx0ZXIoKS0+aW5kZXgoKSAtIEFMVEVSIElOREVYCiAqIC0gYWx0ZXIoKS0+dmlldygpIC0gQUxURVIgVklFVwogKiAtIGFsdGVyKCktPm1hdGVyaWFsaXplZFZpZXcoKSAtIEFMVEVSIE1BVEVSSUFMSVpFRCBWSUVXCiAqIC0gYWx0ZXIoKS0+c2VxdWVuY2UoKSAtIEFMVEVSIFNFUVVFTkNFCiAqIC0gYWx0ZXIoKS0+c2NoZW1hKCkgLSBBTFRFUiBTQ0hFTUEKICogLSBhbHRlcigpLT5yb2xlKCkgLSBBTFRFUiBST0xFCiAqIC0gYWx0ZXIoKS0+ZnVuY3Rpb24oKSAtIEFMVEVSIEZVTkNUSU9OCiAqIC0gYWx0ZXIoKS0+cHJvY2VkdXJlKCkgLSBBTFRFUiBQUk9DRURVUkUKICogLSBhbHRlcigpLT50cmlnZ2VyKCkgLSBBTFRFUiBUUklHR0VSCiAqIC0gYWx0ZXIoKS0+ZXh0ZW5zaW9uKCkgLSBBTFRFUiBFWFRFTlNJT04KICogLSBhbHRlcigpLT5lbnVtVHlwZSgpIC0gQUxURVIgVFlQRSAoZW51bSkKICogLSBhbHRlcigpLT5kb21haW4oKSAtIEFMVEVSIERPTUFJTgogKgogKiBSZW5hbWUgb3BlcmF0aW9ucyBhcmUgYWxzbyB1bmRlciBhbHRlcigpOgogKiAtIGFsdGVyKCktPmluZGV4KCdvbGQnKS0+cmVuYW1lVG8oJ25ldycpCiAqIC0gYWx0ZXIoKS0+dmlldygnb2xkJyktPnJlbmFtZVRvKCduZXcnKQogKiAtIGFsdGVyKCktPnNjaGVtYSgnb2xkJyktPnJlbmFtZVRvKCduZXcnKQogKiAtIGFsdGVyKCktPnJvbGUoJ29sZCcpLT5yZW5hbWVUbygnbmV3JykKICogLSBhbHRlcigpLT50cmlnZ2VyKCdvbGQnKS0+b24oJ3RhYmxlJyktPnJlbmFtZVRvKCduZXcnKQogKgogKiBFeGFtcGxlOiBhbHRlcigpLT50YWJsZSgndXNlcnMnKS0+YWRkQ29sdW1uKGNvbF9kZWYoJ2VtYWlsJywgY29sdW1uX3R5cGVfdGV4dCgpKSkKICogRXhhbXBsZTogYWx0ZXIoKS0+c2VxdWVuY2UoJ3VzZXJfaWRfc2VxJyktPnJlc3RhcnQoMTAwMCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":292,"slug":"truncate-table","name":"truncate_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"TruncateFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Truncate","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRSVU5DQVRFIFRBQkxFIGJ1aWxkZXIuCiAqCiAqIEBwYXJhbSBzdHJpbmcgLi4uJHRhYmxlcyBUYWJsZSBuYW1lcyB0byB0cnVuY2F0ZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":310,"slug":"refresh-materialized-view","name":"refresh_materialized_view","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"RefreshMatViewOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\View\\RefreshMaterializedView","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFRlJFU0ggTUFURVJJQUxJWkVEIFZJRVcgYnVpbGRlci4KICoKICogRXhhbXBsZTogcmVmcmVzaF9tYXRlcmlhbGl6ZWRfdmlldygndXNlcl9zdGF0cycpCiAqIFByb2R1Y2VzOiBSRUZSRVNIIE1BVEVSSUFMSVpFRCBWSUVXIHVzZXJfc3RhdHMKICoKICogRXhhbXBsZTogcmVmcmVzaF9tYXRlcmlhbGl6ZWRfdmlldygndXNlcl9zdGF0cycpLT5jb25jdXJyZW50bHkoKS0+d2l0aERhdGEoKQogKiBQcm9kdWNlczogUkVGUkVTSCBNQVRFUklBTElaRUQgVklFVyBDT05DVVJSRU5UTFkgdXNlcl9zdGF0cyBXSVRIIERBVEEKICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBWaWV3IG5hbWUgKG1heSBpbmNsdWRlIHNjaGVtYSBhcyAic2NoZW1hLnZpZXciKQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNjaGVtYSBTY2hlbWEgbmFtZSAob3B0aW9uYWwsIG92ZXJyaWRlcyBwYXJzZWQgc2NoZW1hKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":319,"slug":"ref-action-cascade","name":"ref_action_cascade","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIENBU0NBREUgcmVmZXJlbnRpYWwgYWN0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":328,"slug":"ref-action-restrict","name":"ref_action_restrict","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIFJFU1RSSUNUIHJlZmVyZW50aWFsIGFjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":337,"slug":"ref-action-set-null","name":"ref_action_set_null","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIFNFVCBOVUxMIHJlZmVyZW50aWFsIGFjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":346,"slug":"ref-action-set-default","name":"ref_action_set_default","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIFNFVCBERUZBVUxUIHJlZmVyZW50aWFsIGFjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":355,"slug":"ref-action-no-action","name":"ref_action_no_action","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIE5PIEFDVElPTiByZWZlcmVudGlhbCBhY3Rpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":370,"slug":"reindex-index","name":"reindex_index","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBJTkRFWCBzdGF0ZW1lbnQuCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5jb25jdXJyZW50bHkoKSwgLT52ZXJib3NlKCksIC0+dGFibGVzcGFjZSgpCiAqCiAqIEV4YW1wbGU6IHJlaW5kZXhfaW5kZXgoJ2lkeF91c2Vyc19lbWFpbCcpLT5jb25jdXJyZW50bHkoKQogKgogKiBAcGFyYW0gc3RyaW5nICRuYW1lIFRoZSBpbmRleCBuYW1lIChtYXkgaW5jbHVkZSBzY2hlbWE6IHNjaGVtYS5pbmRleCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":385,"slug":"reindex-table","name":"reindex_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBUQUJMRSBzdGF0ZW1lbnQuCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5jb25jdXJyZW50bHkoKSwgLT52ZXJib3NlKCksIC0+dGFibGVzcGFjZSgpCiAqCiAqIEV4YW1wbGU6IHJlaW5kZXhfdGFibGUoJ3VzZXJzJyktPmNvbmN1cnJlbnRseSgpCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGhlIHRhYmxlIG5hbWUgKG1heSBpbmNsdWRlIHNjaGVtYTogc2NoZW1hLnRhYmxlKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":400,"slug":"reindex-schema","name":"reindex_schema","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBTQ0hFTUEgc3RhdGVtZW50LgogKgogKiBVc2UgY2hhaW5hYmxlIG1ldGhvZHM6IC0+Y29uY3VycmVudGx5KCksIC0+dmVyYm9zZSgpLCAtPnRhYmxlc3BhY2UoKQogKgogKiBFeGFtcGxlOiByZWluZGV4X3NjaGVtYSgncHVibGljJyktPmNvbmN1cnJlbnRseSgpCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGhlIHNjaGVtYSBuYW1lCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":415,"slug":"reindex-database","name":"reindex_database","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBEQVRBQkFTRSBzdGF0ZW1lbnQuCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5jb25jdXJyZW50bHkoKSwgLT52ZXJib3NlKCksIC0+dGFibGVzcGFjZSgpCiAqCiAqIEV4YW1wbGU6IHJlaW5kZXhfZGF0YWJhc2UoJ215ZGInKS0+Y29uY3VycmVudGx5KCkKICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBUaGUgZGF0YWJhc2UgbmFtZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":430,"slug":"index-col","name":"index_col","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"IndexColumn","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbmRleCBjb2x1bW4gc3BlY2lmaWNhdGlvbi4KICoKICogVXNlIGNoYWluYWJsZSBtZXRob2RzOiAtPmFzYygpLCAtPmRlc2MoKSwgLT5udWxsc0ZpcnN0KCksIC0+bnVsbHNMYXN0KCksIC0+b3BjbGFzcygpLCAtPmNvbGxhdGUoKQogKgogKiBFeGFtcGxlOiBpbmRleF9jb2woJ2VtYWlsJyktPmRlc2MoKS0+bnVsbHNMYXN0KCkKICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBUaGUgY29sdW1uIG5hbWUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":445,"slug":"index-expr","name":"index_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expression","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"IndexColumn","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbmRleCBjb2x1bW4gc3BlY2lmaWNhdGlvbiBmcm9tIGFuIGV4cHJlc3Npb24uCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5hc2MoKSwgLT5kZXNjKCksIC0+bnVsbHNGaXJzdCgpLCAtPm51bGxzTGFzdCgpLCAtPm9wY2xhc3MoKSwgLT5jb2xsYXRlKCkKICoKICogRXhhbXBsZTogaW5kZXhfZXhwcihmbl9jYWxsKCdsb3dlcicsIGNvbCgnZW1haWwnKSkpLT5kZXNjKCkKICoKICogQHBhcmFtIEV4cHJlc3Npb24gJGV4cHJlc3Npb24gVGhlIGV4cHJlc3Npb24gdG8gaW5kZXgKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":454,"slug":"index-method-btree","name":"index_method_btree","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgQlRSRUUgaW5kZXggbWV0aG9kLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":463,"slug":"index-method-hash","name":"index_method_hash","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgSEFTSCBpbmRleCBtZXRob2QuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":472,"slug":"index-method-gist","name":"index_method_gist","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgR0lTVCBpbmRleCBtZXRob2QuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":481,"slug":"index-method-spgist","name":"index_method_spgist","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgU1BHSVNUIGluZGV4IG1ldGhvZC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":490,"slug":"index-method-gin","name":"index_method_gin","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgR0lOIGluZGV4IG1ldGhvZC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":499,"slug":"index-method-brin","name":"index_method_brin","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgQlJJTiBpbmRleCBtZXRob2QuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":511,"slug":"vacuum","name":"vacuum","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"VacuumFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZBQ1VVTSBidWlsZGVyLgogKgogKiBFeGFtcGxlOiB2YWN1dW0oKS0+dGFibGUoJ3VzZXJzJykKICogUHJvZHVjZXM6IFZBQ1VVTSB1c2VycwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":523,"slug":"analyze","name":"analyze","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AnalyzeFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBTkFMWVpFIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IGFuYWx5emUoKS0+dGFibGUoJ3VzZXJzJykKICogUHJvZHVjZXM6IEFOQUxZWkUgdXNlcnMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":537,"slug":"explain","name":"explain","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false},{"name":"InsertBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Insert","is_nullable":false,"is_variadic":false},{"name":"UpdateBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Update","is_nullable":false,"is_variadic":false},{"name":"DeleteBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Delete","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExplainFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFWFBMQUlOIGJ1aWxkZXIgZm9yIGEgcXVlcnkuCiAqCiAqIEV4YW1wbGU6IGV4cGxhaW4oc2VsZWN0KCktPmZyb20oJ3VzZXJzJykpCiAqIFByb2R1Y2VzOiBFWFBMQUlOIFNFTEVDVCAqIEZST00gdXNlcnMKICoKICogQHBhcmFtIERlbGV0ZUJ1aWxkZXJ8SW5zZXJ0QnVpbGRlcnxTZWxlY3RGaW5hbFN0ZXB8VXBkYXRlQnVpbGRlciAkcXVlcnkgUXVlcnkgdG8gZXhwbGFpbgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":549,"slug":"lock-table","name":"lock_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"LockFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExPQ0sgVEFCTEUgYnVpbGRlci4KICoKICogRXhhbXBsZTogbG9ja190YWJsZSgndXNlcnMnLCAnb3JkZXJzJyktPmFjY2Vzc0V4Y2x1c2l2ZSgpCiAqIFByb2R1Y2VzOiBMT0NLIFRBQkxFIHVzZXJzLCBvcmRlcnMgSU4gQUNDRVNTIEVYQ0xVU0lWRSBNT0RFCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":564,"slug":"comment","name":"comment","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"target","type":[{"name":"CommentTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CommentFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTU1FTlQgT04gYnVpbGRlci4KICoKICogRXhhbXBsZTogY29tbWVudChDb21tZW50VGFyZ2V0OjpUQUJMRSwgJ3VzZXJzJyktPmlzKCdVc2VyIGFjY291bnRzIHRhYmxlJykKICogUHJvZHVjZXM6IENPTU1FTlQgT04gVEFCTEUgdXNlcnMgSVMgJ1VzZXIgYWNjb3VudHMgdGFibGUnCiAqCiAqIEBwYXJhbSBDb21tZW50VGFyZ2V0ICR0YXJnZXQgVGFyZ2V0IHR5cGUgKFRBQkxFLCBDT0xVTU4sIElOREVYLCBldGMuKQogKiBAcGFyYW0gc3RyaW5nICRuYW1lIFRhcmdldCBuYW1lICh1c2UgJ3RhYmxlLmNvbHVtbicgZm9yIENPTFVNTiB0YXJnZXRzKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":576,"slug":"cluster","name":"cluster","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ClusterFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENMVVNURVIgYnVpbGRlci4KICoKICogRXhhbXBsZTogY2x1c3RlcigpLT50YWJsZSgndXNlcnMnKS0+dXNpbmcoJ2lkeF91c2Vyc19wa2V5JykKICogUHJvZHVjZXM6IENMVVNURVIgdXNlcnMgVVNJTkcgaWR4X3VzZXJzX3BrZXkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":590,"slug":"discard","name":"discard","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"type","type":[{"name":"DiscardType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DiscardFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERJU0NBUkQgYnVpbGRlci4KICoKICogRXhhbXBsZTogZGlzY2FyZChEaXNjYXJkVHlwZTo6QUxMKQogKiBQcm9kdWNlczogRElTQ0FSRCBBTEwKICoKICogQHBhcmFtIERpc2NhcmRUeXBlICR0eXBlIFR5cGUgb2YgcmVzb3VyY2VzIHRvIGRpc2NhcmQgKEFMTCwgUExBTlMsIFNFUVVFTkNFUywgVEVNUCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":609,"slug":"grant","name":"grant","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"privileges","type":[{"name":"TablePrivilege","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"GrantOnStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdSQU5UIHByaXZpbGVnZXMgYnVpbGRlci4KICoKICogRXhhbXBsZTogZ3JhbnQoVGFibGVQcml2aWxlZ2U6OlNFTEVDVCktPm9uVGFibGUoJ3VzZXJzJyktPnRvKCdhcHBfdXNlcicpCiAqIFByb2R1Y2VzOiBHUkFOVCBTRUxFQ1QgT04gdXNlcnMgVE8gYXBwX3VzZXIKICoKICogRXhhbXBsZTogZ3JhbnQoVGFibGVQcml2aWxlZ2U6OkFMTCktPm9uQWxsVGFibGVzSW5TY2hlbWEoJ3B1YmxpYycpLT50bygnYWRtaW4nKQogKiBQcm9kdWNlczogR1JBTlQgQUxMIE9OIEFMTCBUQUJMRVMgSU4gU0NIRU1BIHB1YmxpYyBUTyBhZG1pbgogKgogKiBAcGFyYW0gc3RyaW5nfFRhYmxlUHJpdmlsZWdlIC4uLiRwcml2aWxlZ2VzIFRoZSBwcml2aWxlZ2VzIHRvIGdyYW50CiAqCiAqIEByZXR1cm4gR3JhbnRPblN0ZXAgQnVpbGRlciBmb3IgZ3JhbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":628,"slug":"grant-role","name":"grant_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"GrantRoleToStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdSQU5UIHJvbGUgYnVpbGRlci4KICoKICogRXhhbXBsZTogZ3JhbnRfcm9sZSgnYWRtaW4nKS0+dG8oJ3VzZXIxJykKICogUHJvZHVjZXM6IEdSQU5UIGFkbWluIFRPIHVzZXIxCiAqCiAqIEV4YW1wbGU6IGdyYW50X3JvbGUoJ2FkbWluJywgJ2RldmVsb3BlcicpLT50bygndXNlcjEnKS0+d2l0aEFkbWluT3B0aW9uKCkKICogUHJvZHVjZXM6IEdSQU5UIGFkbWluLCBkZXZlbG9wZXIgVE8gdXNlcjEgV0lUSCBBRE1JTiBPUFRJT04KICoKICogQHBhcmFtIHN0cmluZyAuLi4kcm9sZXMgVGhlIHJvbGVzIHRvIGdyYW50CiAqCiAqIEByZXR1cm4gR3JhbnRSb2xlVG9TdGVwIEJ1aWxkZXIgZm9yIGdyYW50IHJvbGUgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":647,"slug":"revoke","name":"revoke","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"privileges","type":[{"name":"TablePrivilege","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"RevokeOnStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVk9LRSBwcml2aWxlZ2VzIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJldm9rZShUYWJsZVByaXZpbGVnZTo6U0VMRUNUKS0+b25UYWJsZSgndXNlcnMnKS0+ZnJvbSgnYXBwX3VzZXInKQogKiBQcm9kdWNlczogUkVWT0tFIFNFTEVDVCBPTiB1c2VycyBGUk9NIGFwcF91c2VyCiAqCiAqIEV4YW1wbGU6IHJldm9rZShUYWJsZVByaXZpbGVnZTo6QUxMKS0+b25UYWJsZSgndXNlcnMnKS0+ZnJvbSgnYXBwX3VzZXInKS0+Y2FzY2FkZSgpCiAqIFByb2R1Y2VzOiBSRVZPS0UgQUxMIE9OIHVzZXJzIEZST00gYXBwX3VzZXIgQ0FTQ0FERQogKgogKiBAcGFyYW0gc3RyaW5nfFRhYmxlUHJpdmlsZWdlIC4uLiRwcml2aWxlZ2VzIFRoZSBwcml2aWxlZ2VzIHRvIHJldm9rZQogKgogKiBAcmV0dXJuIFJldm9rZU9uU3RlcCBCdWlsZGVyIGZvciByZXZva2Ugb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":666,"slug":"revoke-role","name":"revoke_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"RevokeRoleFromStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVk9LRSByb2xlIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJldm9rZV9yb2xlKCdhZG1pbicpLT5mcm9tKCd1c2VyMScpCiAqIFByb2R1Y2VzOiBSRVZPS0UgYWRtaW4gRlJPTSB1c2VyMQogKgogKiBFeGFtcGxlOiByZXZva2Vfcm9sZSgnYWRtaW4nKS0+ZnJvbSgndXNlcjEnKS0+Y2FzY2FkZSgpCiAqIFByb2R1Y2VzOiBSRVZPS0UgYWRtaW4gRlJPTSB1c2VyMSBDQVNDQURFCiAqCiAqIEBwYXJhbSBzdHJpbmcgLi4uJHJvbGVzIFRoZSByb2xlcyB0byByZXZva2UKICoKICogQHJldHVybiBSZXZva2VSb2xlRnJvbVN0ZXAgQnVpbGRlciBmb3IgcmV2b2tlIHJvbGUgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":682,"slug":"set-role","name":"set_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"role","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SetRoleFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Session","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBST0xFIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHNldF9yb2xlKCdhZG1pbicpCiAqIFByb2R1Y2VzOiBTRVQgUk9MRSBhZG1pbgogKgogKiBAcGFyYW0gc3RyaW5nICRyb2xlIFRoZSByb2xlIHRvIHNldAogKgogKiBAcmV0dXJuIFNldFJvbGVGaW5hbFN0ZXAgQnVpbGRlciBmb3Igc2V0IHJvbGUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":696,"slug":"reset-role","name":"reset_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ResetRoleFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Session","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFU0VUIFJPTEUgYnVpbGRlci4KICoKICogRXhhbXBsZTogcmVzZXRfcm9sZSgpCiAqIFByb2R1Y2VzOiBSRVNFVCBST0xFCiAqCiAqIEByZXR1cm4gUmVzZXRSb2xlRmluYWxTdGVwIEJ1aWxkZXIgZm9yIHJlc2V0IHJvbGUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":712,"slug":"reassign-owned","name":"reassign_owned","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ReassignOwnedToStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Ownership","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFQVNTSUdOIE9XTkVEIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJlYXNzaWduX293bmVkKCdvbGRfcm9sZScpLT50bygnbmV3X3JvbGUnKQogKiBQcm9kdWNlczogUkVBU1NJR04gT1dORUQgQlkgb2xkX3JvbGUgVE8gbmV3X3JvbGUKICoKICogQHBhcmFtIHN0cmluZyAuLi4kcm9sZXMgVGhlIHJvbGVzIHdob3NlIG93bmVkIG9iamVjdHMgc2hvdWxkIGJlIHJlYXNzaWduZWQKICoKICogQHJldHVybiBSZWFzc2lnbk93bmVkVG9TdGVwIEJ1aWxkZXIgZm9yIHJlYXNzaWduIG93bmVkIG9wdGlvbnMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":731,"slug":"drop-owned","name":"drop_owned","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"DropOwnedFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Ownership","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERST1AgT1dORUQgYnVpbGRlci4KICoKICogRXhhbXBsZTogZHJvcF9vd25lZCgncm9sZTEnKQogKiBQcm9kdWNlczogRFJPUCBPV05FRCBCWSByb2xlMQogKgogKiBFeGFtcGxlOiBkcm9wX293bmVkKCdyb2xlMScsICdyb2xlMicpLT5jYXNjYWRlKCkKICogUHJvZHVjZXM6IERST1AgT1dORUQgQlkgcm9sZTEsIHJvbGUyIENBU0NBREUKICoKICogQHBhcmFtIHN0cmluZyAuLi4kcm9sZXMgVGhlIHJvbGVzIHdob3NlIG93bmVkIG9iamVjdHMgc2hvdWxkIGJlIGRyb3BwZWQKICoKICogQHJldHVybiBEcm9wT3duZWRGaW5hbFN0ZXAgQnVpbGRlciBmb3IgZHJvcCBvd25lZCBvcHRpb25zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":749,"slug":"func-arg","name":"func_arg","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FunctionArgument","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSBuZXcgZnVuY3Rpb24gYXJndW1lbnQgZm9yIHVzZSBpbiBmdW5jdGlvbi9wcm9jZWR1cmUgZGVmaW5pdGlvbnMuCiAqCiAqIEV4YW1wbGU6IGZ1bmNfYXJnKGNvbHVtbl90eXBlX2ludGVnZXIoKSkKICogRXhhbXBsZTogZnVuY19hcmcoY29sdW1uX3R5cGVfdGV4dCgpKS0+bmFtZWQoJ3VzZXJuYW1lJykKICogRXhhbXBsZTogZnVuY19hcmcoY29sdW1uX3R5cGVfaW50ZWdlcigpKS0+bmFtZWQoJ2NvdW50JyktPmRlZmF1bHQoJzAnKQogKiBFeGFtcGxlOiBmdW5jX2FyZyhjb2x1bW5fdHlwZV90ZXh0KCkpLT5vdXQoKQogKgogKiBAcGFyYW0gQ29sdW1uVHlwZSAkdHlwZSBUaGUgUG9zdGdyZVNRTCBkYXRhIHR5cGUgZm9yIHRoZSBhcmd1bWVudAogKgogKiBAcmV0dXJuIEZ1bmN0aW9uQXJndW1lbnQgQnVpbGRlciBmb3IgZnVuY3Rpb24gYXJndW1lbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":768,"slug":"call","name":"call","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"procedure","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CallFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSBDQUxMIHN0YXRlbWVudCBidWlsZGVyIGZvciBpbnZva2luZyBhIHByb2NlZHVyZS4KICoKICogRXhhbXBsZTogY2FsbCgndXBkYXRlX3N0YXRzJyktPndpdGgoMTIzKQogKiBQcm9kdWNlczogQ0FMTCB1cGRhdGVfc3RhdHMoMTIzKQogKgogKiBFeGFtcGxlOiBjYWxsKCdwcm9jZXNzX2RhdGEnKS0+d2l0aCgndGVzdCcsIDQyLCB0cnVlKQogKiBQcm9kdWNlczogQ0FMTCBwcm9jZXNzX2RhdGEoJ3Rlc3QnLCA0MiwgdHJ1ZSkKICoKICogQHBhcmFtIHN0cmluZyAkcHJvY2VkdXJlIFRoZSBuYW1lIG9mIHRoZSBwcm9jZWR1cmUgdG8gY2FsbAogKgogKiBAcmV0dXJuIENhbGxGaW5hbFN0ZXAgQnVpbGRlciBmb3IgY2FsbCBzdGF0ZW1lbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":787,"slug":"do-block","name":"do_block","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"code","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DoFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSBETyBzdGF0ZW1lbnQgYnVpbGRlciBmb3IgZXhlY3V0aW5nIGFuIGFub255bW91cyBjb2RlIGJsb2NrLgogKgogKiBFeGFtcGxlOiBkb19ibG9jaygnQkVHSU4gUkFJU0UgTk9USUNFICQkSGVsbG8gV29ybGQkJDsgRU5EOycpCiAqIFByb2R1Y2VzOiBETyAkJCBCRUdJTiBSQUlTRSBOT1RJQ0UgJCRIZWxsbyBXb3JsZCQkOyBFTkQ7ICQkIExBTkdVQUdFIHBscGdzcWwKICoKICogRXhhbXBsZTogZG9fYmxvY2soJ1NFTEVDVCAxJyktPmxhbmd1YWdlKCdzcWwnKQogKiBQcm9kdWNlczogRE8gJCQgU0VMRUNUIDEgJCQgTEFOR1VBR0Ugc3FsCiAqCiAqIEBwYXJhbSBzdHJpbmcgJGNvZGUgVGhlIGFub255bW91cyBjb2RlIGJsb2NrIHRvIGV4ZWN1dGUKICoKICogQHJldHVybiBEb0ZpbmFsU3RlcCBCdWlsZGVyIGZvciBETyBzdGF0ZW1lbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":807,"slug":"type-attr","name":"type_attr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TypeAttribute","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Type","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSB0eXBlIGF0dHJpYnV0ZSBmb3IgY29tcG9zaXRlIHR5cGVzLgogKgogKiBFeGFtcGxlOiB0eXBlX2F0dHIoJ25hbWUnLCBjb2x1bW5fdHlwZV90ZXh0KCkpCiAqIFByb2R1Y2VzOiBuYW1lIHRleHQKICoKICogRXhhbXBsZTogdHlwZV9hdHRyKCdkZXNjcmlwdGlvbicsIGNvbHVtbl90eXBlX3RleHQoKSktPmNvbGxhdGUoJ2VuX1VTJykKICogUHJvZHVjZXM6IGRlc2NyaXB0aW9uIHRleHQgQ09MTEFURSAiZW5fVVMiCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGhlIGF0dHJpYnV0ZSBuYW1lCiAqIEBwYXJhbSBDb2x1bW5UeXBlICR0eXBlIFRoZSBhdHRyaWJ1dGUgdHlwZQogKgogKiBAcmV0dXJuIFR5cGVBdHRyaWJ1dGUgVHlwZSBhdHRyaWJ1dGUgdmFsdWUgb2JqZWN0CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":816,"slug":"column-type-integer","name":"column_type_integer","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbnRlZ2VyIGRhdGEgdHlwZSAoUG9zdGdyZVNRTCBpbnQ0KS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":825,"slug":"column-type-smallint","name":"column_type_smallint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNtYWxsaW50IGRhdGEgdHlwZSAoUG9zdGdyZVNRTCBpbnQyKS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":834,"slug":"column-type-bigint","name":"column_type_bigint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJpZ2ludCBkYXRhIHR5cGUgKFBvc3RncmVTUUwgaW50OCkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":843,"slug":"column-type-boolean","name":"column_type_boolean","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJvb2xlYW4gZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":852,"slug":"column-type-text","name":"column_type_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRleHQgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":861,"slug":"column-type-varchar","name":"column_type_varchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHZhcmNoYXIgZGF0YSB0eXBlIHdpdGggbGVuZ3RoIGNvbnN0cmFpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":870,"slug":"column-type-char","name":"column_type_char","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNoYXIgZGF0YSB0eXBlIHdpdGggbGVuZ3RoIGNvbnN0cmFpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":879,"slug":"column-type-numeric","name":"column_type_numeric","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG51bWVyaWMgZGF0YSB0eXBlIHdpdGggb3B0aW9uYWwgcHJlY2lzaW9uIGFuZCBzY2FsZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":888,"slug":"column-type-decimal","name":"column_type_decimal","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRlY2ltYWwgZGF0YSB0eXBlIHdpdGggb3B0aW9uYWwgcHJlY2lzaW9uIGFuZCBzY2FsZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":897,"slug":"column-type-real","name":"column_type_real","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJlYWwgZGF0YSB0eXBlIChQb3N0Z3JlU1FMIGZsb2F0NCkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":906,"slug":"column-type-double-precision","name":"column_type_double_precision","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRvdWJsZSBwcmVjaXNpb24gZGF0YSB0eXBlIChQb3N0Z3JlU1FMIGZsb2F0OCkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":915,"slug":"column-type-date","name":"column_type_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRhdGUgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":924,"slug":"column-type-time","name":"column_type_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRpbWUgZGF0YSB0eXBlIHdpdGggb3B0aW9uYWwgcHJlY2lzaW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":933,"slug":"column-type-timestamp","name":"column_type_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRpbWVzdGFtcCBkYXRhIHR5cGUgd2l0aCBvcHRpb25hbCBwcmVjaXNpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":942,"slug":"column-type-timestamptz","name":"column_type_timestamptz","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRpbWVzdGFtcCB3aXRoIHRpbWUgem9uZSBkYXRhIHR5cGUgd2l0aCBvcHRpb25hbCBwcmVjaXNpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":951,"slug":"column-type-interval","name":"column_type_interval","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbnRlcnZhbCBkYXRhIHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":960,"slug":"column-type-uuid","name":"column_type_uuid","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFVVSUQgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":969,"slug":"column-type-json","name":"column_type_json","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":978,"slug":"column-type-jsonb","name":"column_type_jsonb","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":987,"slug":"column-type-bytea","name":"column_type_bytea","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJ5dGVhIGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":996,"slug":"column-type-xml","name":"column_type_xml","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBYTUwgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1005,"slug":"column-type-inet","name":"column_type_inet","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbmV0IGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1014,"slug":"column-type-cidr","name":"column_type_cidr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNpZHIgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1023,"slug":"column-type-macaddr","name":"column_type_macaddr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG1hY2FkZHIgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1032,"slug":"column-type-serial","name":"column_type_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNlcmlhbCBkYXRhIHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1041,"slug":"column-type-smallserial","name":"column_type_smallserial","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNtYWxsc2VyaWFsIGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1050,"slug":"column-type-bigserial","name":"column_type_bigserial","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJpZ3NlcmlhbCBkYXRhIHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1059,"slug":"column-type-array","name":"column_type_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"elementType","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBkYXRhIHR5cGUgZnJvbSBhbiBlbGVtZW50IHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1071,"slug":"column-type-custom","name":"column_type_custom","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"typeName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGN1c3RvbSBkYXRhIHR5cGUuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJHR5cGVOYW1lIFR5cGUgbmFtZQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNjaGVtYSBPcHRpb25hbCBzY2hlbWEgbmFtZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1084,"slug":"column-type-from-string","name":"column_type_from_string","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"typeName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcnNlIGEgUG9zdGdyZVNRTCB0eXBlIHN0cmluZyBpbnRvIGEgQ29sdW1uVHlwZS4KICoKICogSGFuZGxlcyBhbGwgUG9zdGdyZVNRTCB0eXBlIHN5bnRheCBpbmNsdWRpbmcgcHJlY2lzaW9uLCBhcnJheXMsIGFuZCBzY2hlbWEtcXVhbGlmaWVkIHR5cGVzLgogKgogKiBAcGFyYW0gc3RyaW5nICR0eXBlTmFtZSBQb3N0Z3JlU1FMIHR5cGUgc3RyaW5nIChlLmcuLCAnaW50ZWdlcicsICdjaGFyYWN0ZXIgdmFyeWluZygyNTUpJywgJ3RleHRbXScpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1092,"slug":"value-type-text","name":"value_type_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1098,"slug":"value-type-varchar","name":"value_type_varchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1104,"slug":"value-type-char","name":"value_type_char","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1110,"slug":"value-type-bpchar","name":"value_type_bpchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1116,"slug":"value-type-int2","name":"value_type_int2","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1122,"slug":"value-type-smallint","name":"value_type_smallint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1128,"slug":"value-type-int4","name":"value_type_int4","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1134,"slug":"value-type-integer","name":"value_type_integer","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1140,"slug":"value-type-int8","name":"value_type_int8","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1146,"slug":"value-type-bigint","name":"value_type_bigint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1152,"slug":"value-type-float4","name":"value_type_float4","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1158,"slug":"value-type-real","name":"value_type_real","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1164,"slug":"value-type-float8","name":"value_type_float8","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1170,"slug":"value-type-double","name":"value_type_double","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1176,"slug":"value-type-numeric","name":"value_type_numeric","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1182,"slug":"value-type-money","name":"value_type_money","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1188,"slug":"value-type-bool","name":"value_type_bool","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1194,"slug":"value-type-boolean","name":"value_type_boolean","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1200,"slug":"value-type-bytea","name":"value_type_bytea","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1206,"slug":"value-type-bit","name":"value_type_bit","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1212,"slug":"value-type-varbit","name":"value_type_varbit","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1218,"slug":"value-type-date","name":"value_type_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1224,"slug":"value-type-time","name":"value_type_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1230,"slug":"value-type-timetz","name":"value_type_timetz","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1236,"slug":"value-type-timestamp","name":"value_type_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1242,"slug":"value-type-timestamptz","name":"value_type_timestamptz","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1248,"slug":"value-type-interval","name":"value_type_interval","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1254,"slug":"value-type-json","name":"value_type_json","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1260,"slug":"value-type-jsonb","name":"value_type_jsonb","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1266,"slug":"value-type-uuid","name":"value_type_uuid","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1272,"slug":"value-type-inet","name":"value_type_inet","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1278,"slug":"value-type-cidr","name":"value_type_cidr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1284,"slug":"value-type-macaddr","name":"value_type_macaddr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1290,"slug":"value-type-macaddr8","name":"value_type_macaddr8","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1296,"slug":"value-type-xml","name":"value_type_xml","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1302,"slug":"value-type-oid","name":"value_type_oid","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1308,"slug":"value-type-text-array","name":"value_type_text_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1314,"slug":"value-type-varchar-array","name":"value_type_varchar_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1320,"slug":"value-type-int2-array","name":"value_type_int2_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1326,"slug":"value-type-int4-array","name":"value_type_int4_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1332,"slug":"value-type-int8-array","name":"value_type_int8_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1338,"slug":"value-type-float4-array","name":"value_type_float4_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1344,"slug":"value-type-float8-array","name":"value_type_float8_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1350,"slug":"value-type-bool-array","name":"value_type_bool_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1356,"slug":"value-type-uuid-array","name":"value_type_uuid_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1362,"slug":"value-type-json-array","name":"value_type_json_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1368,"slug":"value-type-jsonb-array","name":"value_type_jsonb_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1384,"slug":"schema","name":"schema","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"sequences","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"views","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"materializedViews","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"functions","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"procedures","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"domains","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"extensions","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Schema","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVRhYmxlPiAkdGFibGVzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVNlcXVlbmNlPiAkc2VxdWVuY2VzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVZpZXc+ICR2aWV3cwogKiBAcGFyYW0gbGlzdDxTY2hlbWFNYXRlcmlhbGl6ZWRWaWV3PiAkbWF0ZXJpYWxpemVkVmlld3MKICogQHBhcmFtIGxpc3Q8U2NoZW1hRnVuY3Rpb24+ICRmdW5jdGlvbnMKICogQHBhcmFtIGxpc3Q8U2NoZW1hUHJvY2VkdXJlPiAkcHJvY2VkdXJlcwogKiBAcGFyYW0gbGlzdDxTY2hlbWFEb21haW4+ICRkb21haW5zCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUV4dGVuc2lvbj4gJGV4dGVuc2lvbnMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1420,"slug":"schema-table","name":"schema_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"primaryKey","type":[{"name":"PrimaryKey","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"indexes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"foreignKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"uniqueConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"checkConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"excludeConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"triggers","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'public'"},{"name":"unlogged","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"partitionStrategy","type":[{"name":"PartitionStrategy","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"partitionColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"inherits","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"tablespace","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Table","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxTY2hlbWFDb2x1bW4+ICRjb2x1bW5zCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUluZGV4PiAkaW5kZXhlcwogKiBAcGFyYW0gbGlzdDxTY2hlbWFGb3JlaWduS2V5PiAkZm9yZWlnbktleXMKICogQHBhcmFtIGxpc3Q8U2NoZW1hVW5pcXVlQ29uc3RyYWludD4gJHVuaXF1ZUNvbnN0cmFpbnRzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUNoZWNrQ29uc3RyYWludD4gJGNoZWNrQ29uc3RyYWludHMKICogQHBhcmFtIGxpc3Q8U2NoZW1hRXhjbHVkZUNvbnN0cmFpbnQ+ICRleGNsdWRlQ29uc3RyYWludHMKICogQHBhcmFtIGxpc3Q8U2NoZW1hVHJpZ2dlcj4gJHRyaWdnZXJzCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHBhcnRpdGlvbkNvbHVtbnMKICogQHBhcmFtIGxpc3Q8c3RyaW5nPiAkaW5oZXJpdHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1465,"slug":"schema-table-options","name":"schema_table_options","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"foreignKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"checkConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"excludeConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"triggers","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"unlogged","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"partitionStrategy","type":[{"name":"PartitionStrategy","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"partitionColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"inherits","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"tablespace","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TableOptions","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUZvcmVpZ25LZXk+ICRmb3JlaWduS2V5cwogKiBAcGFyYW0gbGlzdDxTY2hlbWFDaGVja0NvbnN0cmFpbnQ+ICRjaGVja0NvbnN0cmFpbnRzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUV4Y2x1ZGVDb25zdHJhaW50PiAkZXhjbHVkZUNvbnN0cmFpbnRzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVRyaWdnZXI+ICR0cmlnZ2VycwogKiBAcGFyYW0gbGlzdDxzdHJpbmc+ICRwYXJ0aXRpb25Db2x1bW5zCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGluaGVyaXRzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1490,"slug":"schema-column","name":"schema_column","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"isIdentity","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"identityGeneration","type":[{"name":"IdentityGeneration","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"isGenerated","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"generationExpression","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"ordinalPosition","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1515,"slug":"schema-column-integer","name":"schema_column_integer","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1524,"slug":"schema-column-smallint","name":"schema_column_smallint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1533,"slug":"schema-column-bigint","name":"schema_column_bigint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1542,"slug":"schema-column-serial","name":"schema_column_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1548,"slug":"schema-column-small-serial","name":"schema_column_small_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1554,"slug":"schema-column-big-serial","name":"schema_column_big_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1560,"slug":"schema-column-boolean","name":"schema_column_boolean","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1569,"slug":"schema-column-text","name":"schema_column_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1578,"slug":"schema-column-varchar","name":"schema_column_varchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1588,"slug":"schema-column-char","name":"schema_column_char","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1598,"slug":"schema-column-numeric","name":"schema_column_numeric","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1609,"slug":"schema-column-real","name":"schema_column_real","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1618,"slug":"schema-column-double-precision","name":"schema_column_double_precision","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1627,"slug":"schema-column-date","name":"schema_column_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1636,"slug":"schema-column-time","name":"schema_column_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1646,"slug":"schema-column-timestamp","name":"schema_column_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1656,"slug":"schema-column-timestamp-tz","name":"schema_column_timestamp_tz","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1666,"slug":"schema-column-interval","name":"schema_column_interval","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1675,"slug":"schema-column-uuid","name":"schema_column_uuid","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1684,"slug":"schema-column-json","name":"schema_column_json","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1693,"slug":"schema-column-jsonb","name":"schema_column_jsonb","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1702,"slug":"schema-column-bytea","name":"schema_column_bytea","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1711,"slug":"schema-column-inet","name":"schema_column_inet","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1720,"slug":"schema-column-cidr","name":"schema_column_cidr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1729,"slug":"schema-column-macaddr","name":"schema_column_macaddr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1741,"slug":"schema-primary-key","name":"schema_primary_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PrimaryKey","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1751,"slug":"schema-foreign-key","name":"schema_foreign_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceTable","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"referenceSchema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'public'"},{"name":"onUpdate","type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Schema\\ReferentialAction::..."},{"name":"onDelete","type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Schema\\ReferentialAction::..."},{"name":"deferrable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"initiallyDeferred","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"ForeignKey","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRyZWZlcmVuY2VDb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1779,"slug":"schema-unique","name":"schema_unique","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullsNotDistinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"UniqueConstraint","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1785,"slug":"schema-check","name":"schema_check","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expression","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"noInherit","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"CheckConstraint","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1791,"slug":"schema-exclude","name":"schema_exclude","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ExcludeConstraint","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1800,"slug":"schema-index","name":"schema_index","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"unique","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"method","type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\Schema\\IndexMethod::..."},{"name":"primary","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"predicate","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Index","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1812,"slug":"schema-sequence","name":"schema_sequence","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"dataType","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'bigint'"},{"name":"startValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"minValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"maxValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"incrementBy","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"cycle","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"cacheValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"ownedByTable","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"ownedByColumn","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Sequence","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1839,"slug":"schema-view","name":"schema_view","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"isUpdatable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"View","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1848,"slug":"schema-materialized-view","name":"schema_materialized_view","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"indexes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"MaterializedView","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUluZGV4PiAkaW5kZXhlcwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1857,"slug":"schema-function","name":"schema_function","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"returnType","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"argumentTypes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"language","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'sql'"},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"isStrict","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"volatility","type":[{"name":"FunctionVolatility","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Func","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGFyZ3VtZW50VHlwZXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1873,"slug":"schema-procedure","name":"schema_procedure","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"argumentTypes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"language","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'sql'"},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Procedure","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGFyZ3VtZW50VHlwZXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1886,"slug":"schema-trigger","name":"schema_trigger","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tableName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"timing","type":[{"name":"TriggerTiming","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"events","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"functionName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"forEachRow","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"whenCondition","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Trigger","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxUcmlnZ2VyRXZlbnQ+ICRldmVudHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1902,"slug":"schema-domain","name":"schema_domain","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"baseType","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"checkConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Domain","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUNoZWNrQ29uc3RyYWludD4gJGNoZWNrQ29uc3RyYWludHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1913,"slug":"schema-extension","name":"schema_extension","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"version","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Extension","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1922,"slug":"client-catalog-provider","name":"client_catalog_provider","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schemaNames","type":[{"name":"array","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"exclusionPolicy","type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSA\/bGlzdDxzdHJpbmc+ICRzY2hlbWFOYW1lcwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1931,"slug":"exclude-any","name":"exclude_any","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"policies","type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1937,"slug":"exclude-exact","name":"exclude_exact","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1943,"slug":"exclude-starts-with","name":"exclude_starts_with","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"prefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1949,"slug":"exclude-ends-with","name":"exclude_ends_with","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"suffix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1955,"slug":"exclude-pattern","name":"exclude_pattern","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"pattern","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1961,"slug":"exclude-schema","name":"exclude_schema","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1967,"slug":"exclude-scoped","name":"exclude_scoped","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"policy","type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"SchemaObjectType","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1976,"slug":"manual-catalog-provider","name":"manual_catalog_provider","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"catalog","type":[{"name":"Catalog","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1982,"slug":"chain-catalog-provider","name":"chain_catalog_provider","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"providers","type":[{"name":"CatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ChainCatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1991,"slug":"catalog-comparator","name":"catalog_comparator","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"renameStrategy","type":[{"name":"RenameStrategy","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"viewDependencyResolver","type":[{"name":"ViewDependencyResolver","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"tableOrderStrategy","type":[{"name":"ExecutionOrderStrategy","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"dropIfExists","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"CatalogComparator","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBudWxsfEV4ZWN1dGlvbk9yZGVyU3RyYXRlZ3k8XEZsb3dcUG9zdGdyZVNxbFxTY2hlbWFcVGFibGU+ICR0YWJsZU9yZGVyU3RyYXRlZ3kKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2006,"slug":"ast-view-dependency-resolver","name":"ast_view_dependency_resolver","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AstViewDependencyResolver","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2012,"slug":"noop-view-dependency-resolver","name":"noop_view_dependency_resolver","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"NoopViewDependencyResolver","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2018,"slug":"foreign-key-dependency-order","name":"foreign_key_dependency_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ForeignKeyDependencyOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2027,"slug":"no-execution-order","name":"no_execution_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"NoExecutionOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gTm9FeGVjdXRpb25PcmRlcjxtaXhlZD4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2033,"slug":"view-dependency-order","name":"view_dependency_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ViewDependencyOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2039,"slug":"materialized-view-dependency-order","name":"materialized_view_dependency_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"MaterializedViewDependencyOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":117,"slug":"select","name":"select","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"SelectBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBTRUxFQ1QgcXVlcnkgYnVpbGRlci4KICoKICogQHBhcmFtIEV4cHJlc3Npb258c3RyaW5nIC4uLiRleHByZXNzaW9ucyBDb2x1bW5zIHRvIHNlbGVjdC4gSWYgZW1wdHksIHJldHVybnMgU2VsZWN0U2VsZWN0U3RlcC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":134,"slug":"parsed-select","name":"parsed_select","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ParsedSelect","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNlbGVjdEZpbmFsU3RlcCBmcm9tIGEgcmF3IFNRTCBTRUxFQ1Qgc3RyaW5nLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":146,"slug":"with","name":"with","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"ctes","type":[{"name":"CTE","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"WithBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\With","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFdJVEggY2xhdXNlIGJ1aWxkZXIgZm9yIENURXMuCiAqCiAqIEV4YW1wbGU6IHdpdGgoY3RlKCd1c2VycycsICRzdWJxdWVyeSkpLT5zZWxlY3Qoc3RhcigpKS0+ZnJvbSh0YWJsZSgndXNlcnMnKSkKICogRXhhbXBsZTogd2l0aChjdGUoJ2EnLCAkcTEpLCBjdGUoJ2InLCAkcTIpKS0+cmVjdXJzaXZlKCktPnNlbGVjdCguLi4pLT5mcm9tKHRhYmxlKCdhJykpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":159,"slug":"insert","name":"insert","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"InsertIntoStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Insert","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBJTlNFUlQgcXVlcnkgYnVpbGRlci4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":175,"slug":"bulk-insert","name":"bulk_insert","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"rowCount","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BulkInsert","namespace":"Flow\\PostgreSql\\QueryBuilder\\Insert","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBvcHRpbWl6ZWQgYnVsayBJTlNFUlQgcXVlcnkgZm9yIGhpZ2gtcGVyZm9ybWFuY2UgbXVsdGktcm93IGluc2VydHMuCiAqCiAqIFVubGlrZSBpbnNlcnQoKSB3aGljaCB1c2VzIGltbXV0YWJsZSBidWlsZGVyIHBhdHRlcm5zIChPKG7CsikgZm9yIG4gcm93cyksCiAqIHRoaXMgZnVuY3Rpb24gZ2VuZXJhdGVzIFNRTCBkaXJlY3RseSB1c2luZyBzdHJpbmcgb3BlcmF0aW9ucyAoTyhuKSBjb21wbGV4aXR5KS4KICoKICogQHBhcmFtIHN0cmluZyAkdGFibGUgVGFibGUgbmFtZQogKiBAcGFyYW0gbGlzdDxzdHJpbmc+ICRjb2x1bW5zIENvbHVtbiBuYW1lcwogKiBAcGFyYW0gaW50ICRyb3dDb3VudCBOdW1iZXIgb2Ygcm93cyB0byBpbnNlcnQKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":184,"slug":"update","name":"update","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"UpdateTableStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Update","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBVUERBVEUgcXVlcnkgYnVpbGRlci4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":193,"slug":"delete","name":"delete","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"DeleteFromStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Delete","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBERUxFVEUgcXVlcnkgYnVpbGRlci4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":205,"slug":"merge","name":"merge","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"alias","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MergeUsingStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Merge","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBNRVJHRSBxdWVyeSBidWlsZGVyLgogKgogKiBAcGFyYW0gc3RyaW5nICR0YWJsZSBUYXJnZXQgdGFibGUgbmFtZQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGFsaWFzIE9wdGlvbmFsIHRhYmxlIGFsaWFzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":219,"slug":"copy","name":"copy","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"CopyFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBDT1BZIHF1ZXJ5IGJ1aWxkZXIgZm9yIGRhdGEgaW1wb3J0L2V4cG9ydC4KICoKICogVXNhZ2U6CiAqICAgY29weSgpLT5mcm9tKCd1c2VycycpLT5maWxlKCcvdG1wL3VzZXJzLmNzdicpLT5mb3JtYXQoQ29weUZvcm1hdDo6Q1NWKQogKiAgIGNvcHkoKS0+dG8oJ3VzZXJzJyktPmZpbGUoJy90bXAvdXNlcnMuY3N2JyktPmZvcm1hdChDb3B5Rm9ybWF0OjpDU1YpCiAqICAgY29weSgpLT50b1F1ZXJ5KHNlbGVjdCguLi4pKS0+ZmlsZSgnL3RtcC9kYXRhLmNzdicpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":231,"slug":"listen","name":"listen","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"channel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ListenFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Listen","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExJU1RFTiBzdGF0ZW1lbnQgdG8gc3Vic2NyaWJlIHRoZSBjdXJyZW50IHNlc3Npb24gdG8gYSBub3RpZmljYXRpb24gY2hhbm5lbC4KICoKICogVXNhZ2U6CiAqICAgbGlzdGVuKCdteV9jaGFubmVsJyktPnRvU3FsKCkgIC8vIExJU1RFTiBteV9jaGFubmVsCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":243,"slug":"unlisten","name":"unlisten","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"channel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnlistenFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Unlisten","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBVTkxJU1RFTiBzdGF0ZW1lbnQgdG8gdW5zdWJzY3JpYmUgdGhlIGN1cnJlbnQgc2Vzc2lvbiBmcm9tIGEgbm90aWZpY2F0aW9uIGNoYW5uZWwuCiAqCiAqIFVzYWdlOgogKiAgIHVubGlzdGVuKCdteV9jaGFubmVsJyktPnRvU3FsKCkgIC8vIFVOTElTVEVOIG15X2NoYW5uZWwKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":256,"slug":"notify","name":"notify","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"channel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"NotifyFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Notify","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE5PVElGWSBzdGF0ZW1lbnQgdG8gc2VuZCBhIG5vdGlmaWNhdGlvbiBvbiBhIGNoYW5uZWwsIG9wdGlvbmFsbHkgd2l0aCBhIHBheWxvYWQuCiAqCiAqIFVzYWdlOgogKiAgIG5vdGlmeSgnbXlfY2hhbm5lbCcpLT50b1NxbCgpICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gTk9USUZZIG15X2NoYW5uZWwKICogICBub3RpZnkoJ215X2NoYW5uZWwnKS0+d2l0aFBheWxvYWQoJ2hlbGxvJyktPnRvU3FsKCkgICAgIC8vIE5PVElGWSBteV9jaGFubmVsLCAnaGVsbG8nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":277,"slug":"col","name":"col","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbHVtbiByZWZlcmVuY2UgZXhwcmVzc2lvbi4KICoKICogQ2FuIGJlIHVzZWQgaW4gdHdvIG1vZGVzOgogKiAtIFBhcnNlIG1vZGU6IGNvbCgndXNlcnMuaWQnKSBvciBjb2woJ3NjaGVtYS50YWJsZS5jb2x1bW4nKSAtIHBhcnNlcyBkb3Qtc2VwYXJhdGVkIHN0cmluZwogKiAtIEV4cGxpY2l0IG1vZGU6IGNvbCgnaWQnLCAndXNlcnMnKSBvciBjb2woJ2lkJywgJ3VzZXJzJywgJ3NjaGVtYScpIC0gc2VwYXJhdGUgYXJndW1lbnRzCiAqCiAqIFdoZW4gJHRhYmxlIG9yICRzY2hlbWEgaXMgcHJvdmlkZWQsICRjb2x1bW4gbXVzdCBiZSBhIHBsYWluIGNvbHVtbiBuYW1lIChubyBkb3RzKS4KICoKICogQHBhcmFtIHN0cmluZyAkY29sdW1uIENvbHVtbiBuYW1lLCBvciBkb3Qtc2VwYXJhdGVkIHBhdGggbGlrZSAidGFibGUuY29sdW1uIiBvciAic2NoZW1hLnRhYmxlLmNvbHVtbiIKICogQHBhcmFtIG51bGx8c3RyaW5nICR0YWJsZSBUYWJsZSBuYW1lIChvcHRpb25hbCwgdHJpZ2dlcnMgZXhwbGljaXQgbW9kZSkKICogQHBhcmFtIG51bGx8c3RyaW5nICRzY2hlbWEgU2NoZW1hIG5hbWUgKG9wdGlvbmFsLCByZXF1aXJlcyAkdGFibGUpCiAqCiAqIEB0aHJvd3MgSW52YWxpZEV4cHJlc3Npb25FeGNlcHRpb24gd2hlbiAkc2NoZW1hIGlzIHByb3ZpZGVkIHdpdGhvdXQgJHRhYmxlLCBvciB3aGVuICRjb2x1bW4gY29udGFpbnMgZG90cyBpbiBleHBsaWNpdCBtb2RlCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":304,"slug":"star","name":"star","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Star","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFTEVDVCAqIGV4cHJlc3Npb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":320,"slug":"literal","name":"literal","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"value","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Literal","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxpdGVyYWwgdmFsdWUgZm9yIHVzZSBpbiBxdWVyaWVzLgogKgogKiBBdXRvbWF0aWNhbGx5IGRldGVjdHMgdGhlIHR5cGUgYW5kIGNyZWF0ZXMgdGhlIGFwcHJvcHJpYXRlIGxpdGVyYWw6CiAqIC0gbGl0ZXJhbCgnaGVsbG8nKSBjcmVhdGVzIGEgc3RyaW5nIGxpdGVyYWwKICogLSBsaXRlcmFsKDQyKSBjcmVhdGVzIGFuIGludGVnZXIgbGl0ZXJhbAogKiAtIGxpdGVyYWwoMy4xNCkgY3JlYXRlcyBhIGZsb2F0IGxpdGVyYWwKICogLSBsaXRlcmFsKHRydWUpIGNyZWF0ZXMgYSBib29sZWFuIGxpdGVyYWwKICogLSBsaXRlcmFsKG51bGwpIGNyZWF0ZXMgYSBOVUxMIGxpdGVyYWwKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":335,"slug":"param","name":"param","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"position","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Parameter","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHBvc2l0aW9uYWwgcGFyYW1ldGVyICgkMSwgJDIsIGV0Yy4pLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":344,"slug":"parameters","name":"parameters","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"count","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"startAt","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"}],"return_type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gbGlzdDxQYXJhbWV0ZXI+CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":370,"slug":"func","name":"func","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"FunctionCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZ1bmN0aW9uIGNhbGwgZXhwcmVzc2lvbi4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBGdW5jdGlvbiBuYW1lIChjYW4gaW5jbHVkZSBzY2hlbWEgbGlrZSAicGdfY2F0YWxvZy5ub3ciKQogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGFyZ3MgRnVuY3Rpb24gYXJndW1lbnRzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":404,"slug":"agg","name":"agg","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhZ2dyZWdhdGUgZnVuY3Rpb24gY2FsbCAoQ09VTlQsIFNVTSwgQVZHLCBldGMuKS4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBBZ2dyZWdhdGUgZnVuY3Rpb24gbmFtZQogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGFyZ3MgRnVuY3Rpb24gYXJndW1lbnRzCiAqIEBwYXJhbSBib29sICRkaXN0aW5jdCBVc2UgRElTVElOQ1QgbW9kaWZpZXIKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":418,"slug":"agg-count","name":"agg_count","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDT1VOVCgqKSBhZ2dyZWdhdGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":431,"slug":"count-all","name":"count_all","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDT1VOVCgqKSBhZ2dyZWdhdGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":440,"slug":"agg-sum","name":"agg_sum","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBTVU0gYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":449,"slug":"agg-avg","name":"agg_avg","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBBVkcgYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":458,"slug":"agg-min","name":"agg_min","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBNSU4gYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":467,"slug":"agg-max","name":"agg_max","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBNQVggYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":478,"slug":"coalesce","name":"coalesce","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Coalesce","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPQUxFU0NFIGV4cHJlc3Npb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gY29hbGVzY2UKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":489,"slug":"nullif","name":"nullif","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr1","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"expr2","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"NullIf","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE5VTExJRiBleHByZXNzaW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":503,"slug":"greatest","name":"greatest","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Greatest","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdSRUFURVNUIGV4cHJlc3Npb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gY29tcGFyZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":516,"slug":"least","name":"least","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Least","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExFQVNUIGV4cHJlc3Npb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gY29tcGFyZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":530,"slug":"cast","name":"cast","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"dataType","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TypeCast","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHR5cGUgY2FzdCBleHByZXNzaW9uLgogKgogKiBAcGFyYW0gRXhwcmVzc2lvbnxzdHJpbmcgJGV4cHIgRXhwcmVzc2lvbiB0byBjYXN0CiAqIEBwYXJhbSBDb2x1bW5UeXBlICRkYXRhVHlwZSBUYXJnZXQgZGF0YSB0eXBlICh1c2UgY29sdW1uX3R5cGVfKiBmdW5jdGlvbnMpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":542,"slug":"collate","name":"collate","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"collation","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Collate","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTExBVEUgZXhwcmVzc2lvbi4KICoKICogQHBhcmFtIEV4cHJlc3Npb258c3RyaW5nICRleHByIEV4cHJlc3Npb24gdG8gY29sbGF0ZQogKiBAcGFyYW0gc3RyaW5nICRjb2xsYXRpb24gQ29sbGF0aW9uIG5hbWUgYXMgd3JpdHRlbiBpbiBTUUw6ICdDJywgJyJkZV9ERSInLCAncGdfY2F0YWxvZy4iQyInCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":557,"slug":"current-timestamp","name":"current_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SQLValueFunctionExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNRTCBzdGFuZGFyZCBDVVJSRU5UX1RJTUVTVEFNUCBmdW5jdGlvbi4KICoKICogUmV0dXJucyB0aGUgY3VycmVudCBkYXRlIGFuZCB0aW1lIChhdCB0aGUgc3RhcnQgb2YgdGhlIHRyYW5zYWN0aW9uKS4KICogVXNlZnVsIGFzIGEgY29sdW1uIGRlZmF1bHQgdmFsdWUgb3IgaW4gU0VMRUNUIHF1ZXJpZXMuCiAqCiAqIEV4YW1wbGU6IGNvbHVtbignY3JlYXRlZF9hdCcsIGNvbHVtbl90eXBlX3RpbWVzdGFtcCgpKS0+ZGVmYXVsdChjdXJyZW50X3RpbWVzdGFtcCgpKQogKiBFeGFtcGxlOiBzZWxlY3QoKS0+c2VsZWN0KGN1cnJlbnRfdGltZXN0YW1wKCktPmFzKCdub3cnKSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":572,"slug":"current-date","name":"current_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SQLValueFunctionExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNRTCBzdGFuZGFyZCBDVVJSRU5UX0RBVEUgZnVuY3Rpb24uCiAqCiAqIFJldHVybnMgdGhlIGN1cnJlbnQgZGF0ZSAoYXQgdGhlIHN0YXJ0IG9mIHRoZSB0cmFuc2FjdGlvbikuCiAqIFVzZWZ1bCBhcyBhIGNvbHVtbiBkZWZhdWx0IHZhbHVlIG9yIGluIFNFTEVDVCBxdWVyaWVzLgogKgogKiBFeGFtcGxlOiBjb2x1bW4oJ2JpcnRoX2RhdGUnLCBjb2x1bW5fdHlwZV9kYXRlKCkpLT5kZWZhdWx0KGN1cnJlbnRfZGF0ZSgpKQogKiBFeGFtcGxlOiBzZWxlY3QoKS0+c2VsZWN0KGN1cnJlbnRfZGF0ZSgpLT5hcygndG9kYXknKSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":587,"slug":"current-time","name":"current_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SQLValueFunctionExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNRTCBzdGFuZGFyZCBDVVJSRU5UX1RJTUUgZnVuY3Rpb24uCiAqCiAqIFJldHVybnMgdGhlIGN1cnJlbnQgdGltZSAoYXQgdGhlIHN0YXJ0IG9mIHRoZSB0cmFuc2FjdGlvbikuCiAqIFVzZWZ1bCBhcyBhIGNvbHVtbiBkZWZhdWx0IHZhbHVlIG9yIGluIFNFTEVDVCBxdWVyaWVzLgogKgogKiBFeGFtcGxlOiBjb2x1bW4oJ3N0YXJ0X3RpbWUnLCBjb2x1bW5fdHlwZV90aW1lKCkpLT5kZWZhdWx0KGN1cnJlbnRfdGltZSgpKQogKiBFeGFtcGxlOiBzZWxlY3QoKS0+c2VsZWN0KGN1cnJlbnRfdGltZSgpLT5hcygnbm93X3RpbWUnKSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":600,"slug":"case-when","name":"case_when","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"whenClauses","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"elseResult","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"operand","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CaseExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENBU0UgZXhwcmVzc2lvbi4KICoKICogQHBhcmFtIG5vbi1lbXB0eS1saXN0PFdoZW5DbGF1c2U+ICR3aGVuQ2xhdXNlcyBXSEVOIGNsYXVzZXMKICogQHBhcmFtIG51bGx8RXhwcmVzc2lvbnxzdHJpbmcgJGVsc2VSZXN1bHQgRUxTRSByZXN1bHQgKG9wdGlvbmFsKQogKiBAcGFyYW0gbnVsbHxFeHByZXNzaW9ufHN0cmluZyAkb3BlcmFuZCBDQVNFIG9wZXJhbmQgZm9yIHNpbXBsZSBDQVNFIChvcHRpb25hbCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":616,"slug":"when","name":"when","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"condition","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"result","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"WhenClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFdIRU4gY2xhdXNlIGZvciBDQVNFIGV4cHJlc3Npb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":628,"slug":"sub-select","name":"sub_select","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Subquery","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHN1YnF1ZXJ5IGV4cHJlc3Npb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":642,"slug":"array-expr","name":"array_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBleHByZXNzaW9uLgogKgogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGVsZW1lbnRzIEFycmF5IGVsZW1lbnRzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":655,"slug":"row-expr","name":"row_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RowExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJvdyBleHByZXNzaW9uLgogKgogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGVsZW1lbnRzIFJvdyBlbGVtZW50cwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":666,"slug":"binary-expr","name":"binary_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"operator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJpbmFyeSBleHByZXNzaW9uIChsZWZ0IG9wIHJpZ2h0KS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":684,"slug":"window-func","name":"window_func","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"partitionBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"orderBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"WindowFunction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHdpbmRvdyBmdW5jdGlvbi4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBGdW5jdGlvbiBuYW1lCiAqIEBwYXJhbSBsaXN0PEV4cHJlc3Npb258c3RyaW5nPiAkYXJncyBGdW5jdGlvbiBhcmd1bWVudHMKICogQHBhcmFtIGxpc3Q8RXhwcmVzc2lvbnxzdHJpbmc+ICRwYXJ0aXRpb25CeSBQQVJUSVRJT04gQlkgZXhwcmVzc2lvbnMKICogQHBhcmFtIGxpc3Q8T3JkZXJCeT4gJG9yZGVyQnkgT1JERVIgQlkgaXRlbXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":705,"slug":"concat","name":"concat","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbmNhdGVuYXRlIGV4cHJlc3Npb25zIHdpdGggdGhlIHx8IG9wZXJhdG9yLgogKgogKiBFeGFtcGxlOiBjb25jYXQoY29sKCdzY2hlbWEnKSwgbGl0ZXJhbCgnLicpLCBjb2woJ3RhYmxlJykpCiAqIFByb2R1Y2VzOiBzY2hlbWEgfHwgJy4nIHx8IHRhYmxlCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgQXQgbGVhc3QgMiBleHByZXNzaW9ucyB0byBjb25jYXRlbmF0ZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":735,"slug":"table","name":"table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Table","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRhYmxlIHJlZmVyZW5jZS4KICoKICogU3VwcG9ydHMgZG90IG5vdGF0aW9uIGZvciBzY2hlbWEtcXVhbGlmaWVkIG5hbWVzOiAicHVibGljLnVzZXJzIiBvciBleHBsaWNpdCBzY2hlbWEgcGFyYW1ldGVyLgogKiBEb3VibGUtcXVvdGVkIGlkZW50aWZpZXJzIHByZXNlcnZlIGRvdHM6ICcibXkudGFibGUiJyBjcmVhdGVzIGEgc2luZ2xlIGlkZW50aWZpZXIuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGFibGUgbmFtZSAobWF5IGluY2x1ZGUgc2NoZW1hIGFzICJzY2hlbWEudGFibGUiKQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNjaGVtYSBTY2hlbWEgbmFtZSAob3B0aW9uYWwsIG92ZXJyaWRlcyBwYXJzZWQgc2NoZW1hKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":750,"slug":"derived","name":"derived","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"alias","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DerivedTable","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRlcml2ZWQgdGFibGUgKHN1YnF1ZXJ5IGluIEZST00gY2xhdXNlKS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":764,"slug":"lateral","name":"lateral","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"reference","type":[{"name":"TableReference","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Lateral","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExBVEVSQUwgc3VicXVlcnkuCiAqCiAqIEBwYXJhbSBUYWJsZVJlZmVyZW5jZSAkcmVmZXJlbmNlIFRoZSBzdWJxdWVyeSBvciB0YWJsZSBmdW5jdGlvbiByZWZlcmVuY2UKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":776,"slug":"table-func","name":"table_func","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"function","type":[{"name":"FunctionCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"withOrdinality","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"TableFunction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRhYmxlIGZ1bmN0aW9uIHJlZmVyZW5jZS4KICoKICogQHBhcmFtIEZ1bmN0aW9uQ2FsbCAkZnVuY3Rpb24gVGhlIHRhYmxlLXZhbHVlZCBmdW5jdGlvbgogKiBAcGFyYW0gYm9vbCAkd2l0aE9yZGluYWxpdHkgV2hldGhlciB0byBhZGQgV0lUSCBPUkRJTkFMSVRZCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":795,"slug":"values-table","name":"values_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"rows","type":[{"name":"RowExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ValuesTable","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZBTFVFUyBjbGF1c2UgYXMgYSB0YWJsZSByZWZlcmVuY2UuCiAqCiAqIFVzYWdlOgogKiAgIHNlbGVjdCgpLT5mcm9tKAogKiAgICAgICB2YWx1ZXNfdGFibGUoCiAqICAgICAgICAgICByb3dfZXhwcihbbGl0ZXJhbCgxKSwgbGl0ZXJhbCgnQWxpY2UnKV0pLAogKiAgICAgICAgICAgcm93X2V4cHIoW2xpdGVyYWwoMiksIGxpdGVyYWwoJ0JvYicpXSkKICogICAgICAgKS0+YXMoJ3QnLCBbJ2lkJywgJ25hbWUnXSkKICogICApCiAqCiAqIEdlbmVyYXRlczogU0VMRUNUICogRlJPTSAoVkFMVUVTICgxLCAnQWxpY2UnKSwgKDIsICdCb2InKSkgQVMgdChpZCwgbmFtZSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":804,"slug":"order-by","name":"order_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"direction","type":[{"name":"SortDirection","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\SortDirection::..."},{"name":"nulls","type":[{"name":"NullsPosition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\NullsPosition::..."}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPUkRFUiBCWSBpdGVtLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":816,"slug":"asc","name":"asc","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nulls","type":[{"name":"NullsPosition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\NullsPosition::..."}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPUkRFUiBCWSBpdGVtIHdpdGggQVNDIGRpcmVjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":825,"slug":"desc","name":"desc","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nulls","type":[{"name":"NullsPosition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\NullsPosition::..."}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPUkRFUiBCWSBpdGVtIHdpdGggREVTQyBkaXJlY3Rpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":839,"slug":"cte","name":"cte","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columnNames","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"materialization","type":[{"name":"CTEMaterialization","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\CTEMaterialization::..."},{"name":"recursive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"CTE","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENURSAoQ29tbW9uIFRhYmxlIEV4cHJlc3Npb24pLgogKgogKiBAcGFyYW0gc3RyaW5nICRuYW1lIENURSBuYW1lCiAqIEBwYXJhbSBTZWxlY3RGaW5hbFN0ZXAgJHF1ZXJ5IENURSBxdWVyeQogKiBAcGFyYW0gYXJyYXk8c3RyaW5nPiAkY29sdW1uTmFtZXMgQ29sdW1uIGFsaWFzZXMgKG9wdGlvbmFsKQogKiBAcGFyYW0gQ1RFTWF0ZXJpYWxpemF0aW9uICRtYXRlcmlhbGl6YXRpb24gTWF0ZXJpYWxpemF0aW9uIGhpbnQKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":861,"slug":"window-def","name":"window_def","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"partitionBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"orderBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"frame","type":[{"name":"WindowFrame","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"WindowDefinition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHdpbmRvdyBkZWZpbml0aW9uIGZvciBXSU5ET1cgY2xhdXNlLgogKgogKiBAcGFyYW0gc3RyaW5nICRuYW1lIFdpbmRvdyBuYW1lCiAqIEBwYXJhbSBsaXN0PEV4cHJlc3Npb258c3RyaW5nPiAkcGFydGl0aW9uQnkgUEFSVElUSU9OIEJZIGV4cHJlc3Npb25zCiAqIEBwYXJhbSBsaXN0PE9yZGVyQnk+ICRvcmRlckJ5IE9SREVSIEJZIGl0ZW1zCiAqIEBwYXJhbSBudWxsfFdpbmRvd0ZyYW1lICRmcmFtZSBXaW5kb3cgZnJhbWUgc3BlY2lmaWNhdGlvbgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":881,"slug":"window-frame","name":"window_frame","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"mode","type":[{"name":"FrameMode","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end","type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"exclusion","type":[{"name":"FrameExclusion","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\FrameExclusion::..."}],"return_type":[{"name":"WindowFrame","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHdpbmRvdyBmcmFtZSBzcGVjaWZpY2F0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":894,"slug":"frame-current-row","name":"frame_current_row","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBDVVJSRU5UIFJPVy4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":903,"slug":"frame-unbounded-preceding","name":"frame_unbounded_preceding","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBVTkJPVU5ERUQgUFJFQ0VESU5HLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":912,"slug":"frame-unbounded-following","name":"frame_unbounded_following","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBVTkJPVU5ERUQgRk9MTE9XSU5HLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":921,"slug":"frame-preceding","name":"frame_preceding","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"offset","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBOIFBSRUNFRElORy4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":930,"slug":"frame-following","name":"frame_following","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"offset","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBOIEZPTExPV0lORy4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":943,"slug":"lock-for","name":"lock_for","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"strength","type":[{"name":"LockStrength","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"waitPolicy","type":[{"name":"LockWaitPolicy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\LockWaitPolicy::..."}],"return_type":[{"name":"LockingClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxvY2tpbmcgY2xhdXNlIChGT1IgVVBEQVRFLCBGT1IgU0hBUkUsIGV0Yy4pLgogKgogKiBAcGFyYW0gTG9ja1N0cmVuZ3RoICRzdHJlbmd0aCBMb2NrIHN0cmVuZ3RoCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHRhYmxlcyBUYWJsZXMgdG8gbG9jayAoZW1wdHkgZm9yIGFsbCkKICogQHBhcmFtIExvY2tXYWl0UG9saWN5ICR3YWl0UG9saWN5IFdhaXQgcG9saWN5CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":957,"slug":"for-update","name":"for_update","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"LockingClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEZPUiBVUERBVEUgbG9ja2luZyBjbGF1c2UuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHRhYmxlcyBUYWJsZXMgdG8gbG9jayAoZW1wdHkgZm9yIGFsbCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":968,"slug":"for-share","name":"for_share","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"LockingClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEZPUiBTSEFSRSBsb2NraW5nIGNsYXVzZS4KICoKICogQHBhcmFtIGxpc3Q8c3RyaW5nPiAkdGFibGVzIFRhYmxlcyB0byBsb2NrIChlbXB0eSBmb3IgYWxsKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":977,"slug":"on-conflict-nothing","name":"on_conflict_nothing","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"target","type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"OnConflictClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPTiBDT05GTElDVCBETyBOT1RISU5HIGNsYXVzZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":989,"slug":"on-conflict-update","name":"on_conflict_update","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"target","type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"updates","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OnConflictClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPTiBDT05GTElDVCBETyBVUERBVEUgY2xhdXNlLgogKgogKiBAcGFyYW0gQ29uZmxpY3RUYXJnZXQgJHRhcmdldCBDb25mbGljdCB0YXJnZXQgKGNvbHVtbnMgb3IgY29uc3RyYWludCkKICogQHBhcmFtIGFycmF5PHN0cmluZywgRXhwcmVzc2lvbnxzdHJpbmc+ICR1cGRhdGVzIENvbHVtbiB1cGRhdGVzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1003,"slug":"conflict-columns","name":"conflict_columns","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbmZsaWN0IHRhcmdldCBmb3IgT04gQ09ORkxJQ1QgKGNvbHVtbnMpLgogKgogKiBAcGFyYW0gbGlzdDxzdHJpbmc+ICRjb2x1bW5zIENvbHVtbnMgdGhhdCBkZWZpbmUgdW5pcXVlbmVzcwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1012,"slug":"conflict-constraint","name":"conflict_constraint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbmZsaWN0IHRhcmdldCBmb3IgT04gQ09ORkxJQ1QgT04gQ09OU1RSQUlOVC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1023,"slug":"returning","name":"returning","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ReturningClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVFVSTklORyBjbGF1c2UuCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gcmV0dXJuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1034,"slug":"returning-all","name":"returning_all","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReturningClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVFVSTklORyAqIGNsYXVzZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1046,"slug":"begin","name":"begin","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"BeginOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJFR0lOIHRyYW5zYWN0aW9uIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IGJlZ2luKCktPmlzb2xhdGlvbkxldmVsKElzb2xhdGlvbkxldmVsOjpTRVJJQUxJWkFCTEUpLT5yZWFkT25seSgpCiAqIFByb2R1Y2VzOiBCRUdJTiBJU09MQVRJT04gTEVWRUwgU0VSSUFMSVpBQkxFIFJFQUQgT05MWQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1058,"slug":"commit","name":"commit","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"CommitOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTU1JVCB0cmFuc2FjdGlvbiBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBjb21taXQoKS0+YW5kQ2hhaW4oKQogKiBQcm9kdWNlczogQ09NTUlUIEFORCBDSEFJTgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1070,"slug":"rollback","name":"rollback","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"RollbackOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJPTExCQUNLIHRyYW5zYWN0aW9uIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJvbGxiYWNrKCktPnRvU2F2ZXBvaW50KCdteV9zYXZlcG9pbnQnKQogKiBQcm9kdWNlczogUk9MTEJBQ0sgVE8gU0FWRVBPSU5UIG15X3NhdmVwb2ludAogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1082,"slug":"savepoint","name":"savepoint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SavepointFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNBVkVQT0lOVC4KICoKICogRXhhbXBsZTogc2F2ZXBvaW50KCdteV9zYXZlcG9pbnQnKQogKiBQcm9kdWNlczogU0FWRVBPSU5UIG15X3NhdmVwb2ludAogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1094,"slug":"release-savepoint","name":"release_savepoint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SavepointFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJlbGVhc2UgYSBTQVZFUE9JTlQuCiAqCiAqIEV4YW1wbGU6IHJlbGVhc2Vfc2F2ZXBvaW50KCdteV9zYXZlcG9pbnQnKQogKiBQcm9kdWNlczogUkVMRUFTRSBteV9zYXZlcG9pbnQKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1106,"slug":"set-transaction","name":"set_transaction","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SetTransactionOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBUUkFOU0FDVElPTiBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBzZXRfdHJhbnNhY3Rpb24oKS0+aXNvbGF0aW9uTGV2ZWwoSXNvbGF0aW9uTGV2ZWw6OlNFUklBTElaQUJMRSktPnJlYWRPbmx5KCkKICogUHJvZHVjZXM6IFNFVCBUUkFOU0FDVElPTiBJU09MQVRJT04gTEVWRUwgU0VSSUFMSVpBQkxFLCBSRUFEIE9OTFkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1118,"slug":"set-session-transaction","name":"set_session_transaction","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SetTransactionOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBTRVNTSU9OIENIQVJBQ1RFUklTVElDUyBBUyBUUkFOU0FDVElPTiBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBzZXRfc2Vzc2lvbl90cmFuc2FjdGlvbigpLT5pc29sYXRpb25MZXZlbChJc29sYXRpb25MZXZlbDo6U0VSSUFMSVpBQkxFKQogKiBQcm9kdWNlczogU0VUIFNFU1NJT04gQ0hBUkFDVEVSSVNUSUNTIEFTIFRSQU5TQUNUSU9OIElTT0xBVElPTiBMRVZFTCBTRVJJQUxJWkFCTEUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1130,"slug":"transaction-snapshot","name":"transaction_snapshot","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"snapshotId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SetTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBUUkFOU0FDVElPTiBTTkFQU0hPVCBidWlsZGVyLgogKgogKiBFeGFtcGxlOiB0cmFuc2FjdGlvbl9zbmFwc2hvdCgnMDAwMDAwMDMtMDAwMDAwMUEtMScpCiAqIFByb2R1Y2VzOiBTRVQgVFJBTlNBQ1RJT04gU05BUFNIT1QgJzAwMDAwMDAzLTAwMDAwMDFBLTEnCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1142,"slug":"prepare-transaction","name":"prepare_transaction","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"transactionId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PreparedTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBSRVBBUkUgVFJBTlNBQ1RJT04gYnVpbGRlci4KICoKICogRXhhbXBsZTogcHJlcGFyZV90cmFuc2FjdGlvbignbXlfdHJhbnNhY3Rpb24nKQogKiBQcm9kdWNlczogUFJFUEFSRSBUUkFOU0FDVElPTiAnbXlfdHJhbnNhY3Rpb24nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1154,"slug":"commit-prepared","name":"commit_prepared","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"transactionId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PreparedTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTU1JVCBQUkVQQVJFRCBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBjb21taXRfcHJlcGFyZWQoJ215X3RyYW5zYWN0aW9uJykKICogUHJvZHVjZXM6IENPTU1JVCBQUkVQQVJFRCAnbXlfdHJhbnNhY3Rpb24nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1166,"slug":"rollback-prepared","name":"rollback_prepared","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"transactionId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PreparedTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJPTExCQUNLIFBSRVBBUkVEIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJvbGxiYWNrX3ByZXBhcmVkKCdteV90cmFuc2FjdGlvbicpCiAqIFByb2R1Y2VzOiBST0xMQkFDSyBQUkVQQVJFRCAnbXlfdHJhbnNhY3Rpb24nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1189,"slug":"declare-cursor","name":"declare_cursor","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"cursorName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false},{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DeclareCursorOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Cursor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERlY2xhcmUgYSBzZXJ2ZXItc2lkZSBjdXJzb3IgZm9yIGEgcXVlcnkuCiAqCiAqIEN1cnNvcnMgbXVzdCBiZSBkZWNsYXJlZCB3aXRoaW4gYSB0cmFuc2FjdGlvbiBhbmQgcHJvdmlkZSBtZW1vcnktZWZmaWNpZW50CiAqIGl0ZXJhdGlvbiBvdmVyIGxhcmdlIHJlc3VsdCBzZXRzIHZpYSBGRVRDSCBjb21tYW5kcy4KICoKICogRXhhbXBsZSB3aXRoIHF1ZXJ5IGJ1aWxkZXI6CiAqICAgZGVjbGFyZV9jdXJzb3IoJ215X2N1cnNvcicsIHNlbGVjdChzdGFyKCkpLT5mcm9tKHRhYmxlKCd1c2VycycpKSktPm5vU2Nyb2xsKCkKICogICBQcm9kdWNlczogREVDTEFSRSBteV9jdXJzb3IgTk8gU0NST0xMIENVUlNPUiBGT1IgU0VMRUNUICogRlJPTSB1c2VycwogKgogKiBFeGFtcGxlIHdpdGggcmF3IFNRTDoKICogICBkZWNsYXJlX2N1cnNvcignbXlfY3Vyc29yJywgJ1NFTEVDVCAqIEZST00gdXNlcnMgV0hFUkUgYWN0aXZlID0gdHJ1ZScpLT53aXRoSG9sZCgpCiAqICAgUHJvZHVjZXM6IERFQ0xBUkUgbXlfY3Vyc29yIE5PIFNDUk9MTCBDVVJTT1IgV0lUSCBIT0xEIEZPUiBTRUxFQ1QgKiBGUk9NIHVzZXJzIFdIRVJFIGFjdGl2ZSA9IHRydWUKICoKICogQHBhcmFtIHN0cmluZyAkY3Vyc29yTmFtZSBVbmlxdWUgY3Vyc29yIG5hbWUKICogQHBhcmFtIFBhcnNlZFF1ZXJ5fFNlbGVjdEZpbmFsU3RlcHxTcWx8c3RyaW5nICRxdWVyeSBRdWVyeSB0byBpdGVyYXRlIG92ZXIKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1214,"slug":"fetch","name":"fetch","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"cursorName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FetchCursorBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Cursor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEZldGNoIHJvd3MgZnJvbSBhIGN1cnNvci4KICoKICogRXhhbXBsZTogZmV0Y2goJ215X2N1cnNvcicpLT5mb3J3YXJkKDEwMCkKICogUHJvZHVjZXM6IEZFVENIIEZPUldBUkQgMTAwIG15X2N1cnNvcgogKgogKiBFeGFtcGxlOiBmZXRjaCgnbXlfY3Vyc29yJyktPmFsbCgpCiAqIFByb2R1Y2VzOiBGRVRDSCBBTEwgbXlfY3Vyc29yCiAqCiAqIEBwYXJhbSBzdHJpbmcgJGN1cnNvck5hbWUgQ3Vyc29yIHRvIGZldGNoIGZyb20KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1231,"slug":"close-cursor","name":"close_cursor","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"cursorName","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CloseCursorFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Cursor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENsb3NlIGEgY3Vyc29yLgogKgogKiBFeGFtcGxlOiBjbG9zZV9jdXJzb3IoJ215X2N1cnNvcicpCiAqIFByb2R1Y2VzOiBDTE9TRSBteV9jdXJzb3IKICoKICogRXhhbXBsZTogY2xvc2VfY3Vyc29yKCkgLSBjbG9zZXMgYWxsIGN1cnNvcnMKICogUHJvZHVjZXM6IENMT1NFIEFMTAogKgogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGN1cnNvck5hbWUgQ3Vyc29yIHRvIGNsb3NlLCBvciBudWxsIHRvIGNsb3NlIGFsbAogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":42,"slug":"eq","name":"eq","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBlcXVhbGl0eSBjb21wYXJpc29uIChjb2x1bW4gPSB2YWx1ZSkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":55,"slug":"ne","name":"ne","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5vdC1lcXVhbCBjb21wYXJpc29uIChjb2x1bW4gIT0gdmFsdWUpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":68,"slug":"lt","name":"lt","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxlc3MtdGhhbiBjb21wYXJpc29uIChjb2x1bW4gPCB2YWx1ZSkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":81,"slug":"le","name":"le","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxlc3MtdGhhbi1vci1lcXVhbCBjb21wYXJpc29uIChjb2x1bW4gPD0gdmFsdWUpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":94,"slug":"gt","name":"gt","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGdyZWF0ZXItdGhhbiBjb21wYXJpc29uIChjb2x1bW4gPiB2YWx1ZSkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":107,"slug":"ge","name":"ge","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGdyZWF0ZXItdGhhbi1vci1lcXVhbCBjb21wYXJpc29uIChjb2x1bW4gPj0gdmFsdWUpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":120,"slug":"between","name":"between","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"low","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"high","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"not","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Between","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJFVFdFRU4gY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":139,"slug":"in","name":"in_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"values","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"In","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJTiBjb25kaXRpb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAkZXhwciBFeHByZXNzaW9uIHRvIGNoZWNrCiAqIEBwYXJhbSBsaXN0PEV4cHJlc3Npb24+ICR2YWx1ZXMgTGlzdCBvZiB2YWx1ZXMgKG11c3QgYmUgbm9uLWVtcHR5KQogKgogKiBAdGhyb3dzIFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24gd2hlbiB2YWx1ZXMgYXJyYXkgaXMgZW1wdHkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":156,"slug":"is-null","name":"is_null","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"not","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"IsNull","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJUyBOVUxMIGNvbmRpdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":165,"slug":"like","name":"like","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"caseInsensitive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"negated","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Like","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExJS0UgY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":183,"slug":"similar-to","name":"similar_to","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SimilarTo","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNJTUlMQVIgVE8gY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":195,"slug":"distinct-from","name":"distinct_from","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"not","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"IsDistinctFrom","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJUyBESVNUSU5DVCBGUk9NIGNvbmRpdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":208,"slug":"exists","name":"exists","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"subquery","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Exists","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFWElTVFMgY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":223,"slug":"any","name":"any_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"operator","type":[{"name":"ComparisonOperator","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"arrayOrSubquery","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBTlkgY29uZGl0aW9uIHdpdGggYSBzdWJxdWVyeSBvciBhcnJheSBleHByZXNzaW9uLgogKgogKiBFeGFtcGxlOiBhbnlfKGNvbCgnaWQnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpFUSwgc2VsZWN0KGNvbCgndXNlcl9pZCcpKS0+ZnJvbSh0YWJsZSgnb3JkZXJzJykpKQogKiBFeGFtcGxlOiBhbnlfKGNvbCgnYXR0bnVtJywgJ2EnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpFUSwgY29sKCdjb25rZXknLCAnY29uJykpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":243,"slug":"all","name":"all_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"operator","type":[{"name":"ComparisonOperator","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"arrayOrSubquery","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBTEwgY29uZGl0aW9uIHdpdGggYSBzdWJxdWVyeSBvciBhcnJheSBleHByZXNzaW9uLgogKgogKiBFeGFtcGxlOiBhbGxfKGNvbCgnaWQnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpFUSwgc2VsZWN0KGNvbCgndXNlcl9pZCcpKS0+ZnJvbSh0YWJsZSgnb3JkZXJzJykpKQogKiBFeGFtcGxlOiBhbGxfKGNvbCgndmFsdWUnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpHVCwgY29sKCd0aHJlc2hvbGRzJykpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":262,"slug":"is-true","name":"is_true","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BooleanCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYW4gZXhwcmVzc2lvbiBhcyBhIGJvb2xlYW4gY29uZGl0aW9uIGZvciB1c2UgaW4gV0hFUkUvSEFWSU5HL0pPSU4gT04uCiAqCiAqIEV4YW1wbGU6IGlzX3RydWUoY29sKCdpc19hY3RpdmUnKSkg4oCUIHVzZXMgYSBib29sZWFuIGNvbHVtbiBpbiBXSEVSRSBjbGF1c2UuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":274,"slug":"not-like","name":"not_like","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"caseInsensitive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Like","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE5PVCBMSUtFIGNvbmRpdGlvbi4KICoKICogRXhhbXBsZTogbm90X2xpa2UoY29sKCduYW1lJyksIGxpdGVyYWwoJ3BnXyUnKSkKICogUHJvZHVjZXM6IG5hbWUgTk9UIExJS0UgJ3BnXyUnCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":302,"slug":"conditions","name":"conditions","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ConditionBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbmRpdGlvbiBidWlsZGVyIGZvciBmbHVlbnQgY29uZGl0aW9uIGNvbXBvc2l0aW9uLgogKgogKiBUaGlzIGJ1aWxkZXIgYWxsb3dzIGluY3JlbWVudGFsIGNvbmRpdGlvbiBidWlsZGluZyB3aXRoIGEgZmx1ZW50IEFQSToKICoKICogYGBgcGhwCiAqICRidWlsZGVyID0gY29uZGl0aW9ucygpOwogKgogKiBpZiAoJGhhc0ZpbHRlcikgewogKiAgICAgJGJ1aWxkZXIgPSAkYnVpbGRlci0+YW5kKGVxKGNvbCgnc3RhdHVzJyksIGxpdGVyYWwoJ2FjdGl2ZScpKSk7CiAqIH0KICoKICogaWYgKCEkYnVpbGRlci0+aXNFbXB0eSgpKSB7CiAqICAgICAkcXVlcnkgPSBzZWxlY3QoKS0+ZnJvbSh0YWJsZSgndXNlcnMnKSktPndoZXJlKCRidWlsZGVyKTsKICogfQogKiBgYGAKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":313,"slug":"and","name":"and_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"conditions","type":[{"name":"Condition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"AndCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgY29uZGl0aW9ucyB3aXRoIEFORC4KICoKICogQHBhcmFtIENvbmRpdGlvbiAuLi4kY29uZGl0aW9ucyBDb25kaXRpb25zIHRvIGNvbWJpbmUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":324,"slug":"or","name":"or_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"conditions","type":[{"name":"Condition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"OrCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgY29uZGl0aW9ucyB3aXRoIE9SLgogKgogKiBAcGFyYW0gQ29uZGl0aW9uIC4uLiRjb25kaXRpb25zIENvbmRpdGlvbnMgdG8gY29tYmluZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":336,"slug":"not","name":"not_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expression","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"NotCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5lZ2F0ZSBhIGNvbmRpdGlvbiBvciBleHByZXNzaW9uIHdpdGggTk9ULgogKgogKiBBY2NlcHRzIGJvdGggQ29uZGl0aW9uIGFuZCBFeHByZXNzaW9uIOKAlCBOT1QgYWx3YXlzIHByb2R1Y2VzIGEgYm9vbGVhbiByZXN1bHQuCiAqIENhbiBiZSB1c2VkIGluIFdIRVJFIGNsYXVzZXMgYW5kIFNFTEVDVCBsaXN0cyAodmlhIC0+YXMoJ2FsaWFzJykpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":348,"slug":"json-contains","name":"json_contains","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGNvbnRhaW5zIGNvbmRpdGlvbiAoQD4pLgogKgogKiBFeGFtcGxlOiBqc29uX2NvbnRhaW5zKGNvbCgnbWV0YWRhdGEnKSwgbGl0ZXJhbF9qc29uKCd7ImNhdGVnb3J5IjogImVsZWN0cm9uaWNzIn0nKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhIEA+ICd7ImNhdGVnb3J5IjogImVsZWN0cm9uaWNzIn0nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":364,"slug":"json-contained-by","name":"json_contained_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGlzIGNvbnRhaW5lZCBieSBjb25kaXRpb24gKDxAKS4KICoKICogRXhhbXBsZToganNvbl9jb250YWluZWRfYnkoY29sKCdtZXRhZGF0YScpLCBsaXRlcmFsX2pzb24oJ3siY2F0ZWdvcnkiOiAiZWxlY3Ryb25pY3MiLCAicHJpY2UiOiAxMDB9JykpCiAqIFByb2R1Y2VzOiBtZXRhZGF0YSA8QCAneyJjYXRlZ29yeSI6ICJlbGVjdHJvbmljcyIsICJwcmljZSI6IDEwMH0nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":381,"slug":"json-get","name":"json_get","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gZmllbGQgYWNjZXNzIGV4cHJlc3Npb24gKC0+KS4KICogUmV0dXJucyBKU09OLgogKgogKiBFeGFtcGxlOiBqc29uX2dldChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCdjYXRlZ29yeScpKQogKiBQcm9kdWNlczogbWV0YWRhdGEgLT4gJ2NhdGVnb3J5JwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":398,"slug":"json-get-text","name":"json_get_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gZmllbGQgYWNjZXNzIGV4cHJlc3Npb24gKC0+PikuCiAqIFJldHVybnMgdGV4dC4KICoKICogRXhhbXBsZToganNvbl9nZXRfdGV4dChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCduYW1lJykpCiAqIFByb2R1Y2VzOiBtZXRhZGF0YSAtPj4gJ25hbWUnCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":415,"slug":"json-path","name":"json_path","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gcGF0aCBhY2Nlc3MgZXhwcmVzc2lvbiAoIz4pLgogKiBSZXR1cm5zIEpTT04uCiAqCiAqIEV4YW1wbGU6IGpzb25fcGF0aChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCd7Y2F0ZWdvcnksbmFtZX0nKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhICM+ICd7Y2F0ZWdvcnksbmFtZX0nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":432,"slug":"json-path-text","name":"json_path_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gcGF0aCBhY2Nlc3MgZXhwcmVzc2lvbiAoIz4+KS4KICogUmV0dXJucyB0ZXh0LgogKgogKiBFeGFtcGxlOiBqc29uX3BhdGhfdGV4dChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCd7Y2F0ZWdvcnksbmFtZX0nKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhICM+PiAne2NhdGVnb3J5LG5hbWV9JwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":448,"slug":"json-exists","name":"json_exists","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGtleSBleGlzdHMgY29uZGl0aW9uICg\/KS4KICoKICogRXhhbXBsZToganNvbl9leGlzdHMoY29sKCdtZXRhZGF0YScpLCBsaXRlcmFsX3N0cmluZygnY2F0ZWdvcnknKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhID8gJ2NhdGVnb3J5JwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":464,"slug":"json-exists-any","name":"json_exists_any","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGFueSBrZXkgZXhpc3RzIGNvbmRpdGlvbiAoP3wpLgogKgogKiBFeGFtcGxlOiBqc29uX2V4aXN0c19hbnkoY29sKCdtZXRhZGF0YScpLCBhcnJheV9leHByKFtsaXRlcmFsKCdjYXRlZ29yeScpLCBsaXRlcmFsKCduYW1lJyldKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhID98IGFycmF5WydjYXRlZ29yeScsICduYW1lJ10KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":480,"slug":"json-exists-all","name":"json_exists_all","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGFsbCBrZXlzIGV4aXN0IGNvbmRpdGlvbiAoPyYpLgogKgogKiBFeGFtcGxlOiBqc29uX2V4aXN0c19hbGwoY29sKCdtZXRhZGF0YScpLCBhcnJheV9leHByKFtsaXRlcmFsKCdjYXRlZ29yeScpLCBsaXRlcmFsKCduYW1lJyldKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhID8mIGFycmF5WydjYXRlZ29yeScsICduYW1lJ10KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":496,"slug":"array-contains","name":"array_contains","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBjb250YWlucyBjb25kaXRpb24gKEA+KS4KICoKICogRXhhbXBsZTogYXJyYXlfY29udGFpbnMoY29sKCd0YWdzJyksIGFycmF5X2V4cHIoW2xpdGVyYWwoJ3NhbGUnKV0pKQogKiBQcm9kdWNlczogdGFncyBAPiBBUlJBWVsnc2FsZSddCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":512,"slug":"array-contained-by","name":"array_contained_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBpcyBjb250YWluZWQgYnkgY29uZGl0aW9uICg8QCkuCiAqCiAqIEV4YW1wbGU6IGFycmF5X2NvbnRhaW5lZF9ieShjb2woJ3RhZ3MnKSwgYXJyYXlfZXhwcihbbGl0ZXJhbCgnc2FsZScpLCBsaXRlcmFsKCdmZWF0dXJlZCcpLCBsaXRlcmFsKCduZXcnKV0pKQogKiBQcm9kdWNlczogdGFncyA8QCBBUlJBWVsnc2FsZScsICdmZWF0dXJlZCcsICduZXcnXQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":528,"slug":"array-overlap","name":"array_overlap","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBvdmVybGFwIGNvbmRpdGlvbiAoJiYpLgogKgogKiBFeGFtcGxlOiBhcnJheV9vdmVybGFwKGNvbCgndGFncycpLCBhcnJheV9leHByKFtsaXRlcmFsKCdzYWxlJyksIGxpdGVyYWwoJ2ZlYXR1cmVkJyldKSkKICogUHJvZHVjZXM6IHRhZ3MgJiYgQVJSQVlbJ3NhbGUnLCAnZmVhdHVyZWQnXQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":546,"slug":"regex-match","name":"regex_match","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG1hdGNoIGNvbmRpdGlvbiAofikuCiAqIENhc2Utc2Vuc2l0aXZlLgogKgogKiBFeGFtcGxlOiByZWdleF9tYXRjaChjb2woJ2VtYWlsJyksIGxpdGVyYWxfc3RyaW5nKCcuKkBnbWFpbFxcLmNvbScpKQogKgogKiBQcm9kdWNlczogZW1haWwgfiAnLipAZ21haWxcLmNvbScKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":564,"slug":"regex-imatch","name":"regex_imatch","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG1hdGNoIGNvbmRpdGlvbiAofiopLgogKiBDYXNlLWluc2Vuc2l0aXZlLgogKgogKiBFeGFtcGxlOiByZWdleF9pbWF0Y2goY29sKCdlbWFpbCcpLCBsaXRlcmFsX3N0cmluZygnLipAZ21haWxcXC5jb20nKSkKICoKICogUHJvZHVjZXM6IGVtYWlsIH4qICcuKkBnbWFpbFwuY29tJwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":582,"slug":"not-regex-match","name":"not_regex_match","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG5vdCBtYXRjaCBjb25kaXRpb24gKCF+KS4KICogQ2FzZS1zZW5zaXRpdmUuCiAqCiAqIEV4YW1wbGU6IG5vdF9yZWdleF9tYXRjaChjb2woJ2VtYWlsJyksIGxpdGVyYWxfc3RyaW5nKCcuKkBzcGFtXFwuY29tJykpCiAqCiAqIFByb2R1Y2VzOiBlbWFpbCAhfiAnLipAc3BhbVwuY29tJwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":600,"slug":"not-regex-imatch","name":"not_regex_imatch","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG5vdCBtYXRjaCBjb25kaXRpb24gKCF+KikuCiAqIENhc2UtaW5zZW5zaXRpdmUuCiAqCiAqIEV4YW1wbGU6IG5vdF9yZWdleF9pbWF0Y2goY29sKCdlbWFpbCcpLCBsaXRlcmFsX3N0cmluZygnLipAc3BhbVxcLmNvbScpKQogKgogKiBQcm9kdWNlczogZW1haWwgIX4qICcuKkBzcGFtXC5jb20nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":616,"slug":"text-search-match","name":"text_search_match","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"document","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZ1bGwtdGV4dCBzZWFyY2ggbWF0Y2ggY29uZGl0aW9uIChAQCkuCiAqCiAqIEV4YW1wbGU6IHRleHRfc2VhcmNoX21hdGNoKGNvbCgnZG9jdW1lbnQnKSwgZnVuYygndG9fdHNxdWVyeScsIFtsaXRlcmFsKCdlbmdsaXNoJyksIGxpdGVyYWwoJ2hlbGxvICYgd29ybGQnKV0pKQogKiBQcm9kdWNlczogZG9jdW1lbnQgQEAgdG9fdHNxdWVyeSgnZW5nbGlzaCcsICdoZWxsbyAmIHdvcmxkJykKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":33,"slug":"sql-parser","name":"sql_parser","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"Parser","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":39,"slug":"sql-parse","name":"sql_parse","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":49,"slug":"sql-fingerprint","name":"sql_fingerprint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJldHVybnMgYSBmaW5nZXJwcmludCBvZiB0aGUgZ2l2ZW4gU1FMIHF1ZXJ5LgogKiBMaXRlcmFsIHZhbHVlcyBhcmUgbm9ybWFsaXplZCBzbyB0aGV5IHdvbid0IGFmZmVjdCB0aGUgZmluZ2VycHJpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":60,"slug":"sql-normalize","name":"sql_normalize","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5vcm1hbGl6ZSBTUUwgcXVlcnkgYnkgcmVwbGFjaW5nIGxpdGVyYWwgdmFsdWVzIGFuZCBuYW1lZCBwYXJhbWV0ZXJzIHdpdGggcG9zaXRpb25hbCBwYXJhbWV0ZXJzLgogKiBXSEVSRSBpZCA9IDppZCB3aWxsIGJlIGNoYW5nZWQgaW50byBXSEVSRSBpZCA9ICQxCiAqIFdIRVJFIGlkID0gMSB3aWxsIGJlIGNoYW5nZWQgaW50byBXSEVSRSBpZCA9ICQxLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":70,"slug":"sql-normalize-utility","name":"sql_normalize_utility","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5vcm1hbGl6ZSB1dGlsaXR5IFNRTCBzdGF0ZW1lbnRzIChEREwgbGlrZSBDUkVBVEUsIEFMVEVSLCBEUk9QKS4KICogVGhpcyBoYW5kbGVzIERETCBzdGF0ZW1lbnRzIGRpZmZlcmVudGx5IGZyb20gcGdfbm9ybWFsaXplKCkgd2hpY2ggaXMgb3B0aW1pemVkIGZvciBETUwuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":81,"slug":"sql-split","name":"sql_split","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNwbGl0IHN0cmluZyB3aXRoIG11bHRpcGxlIFNRTCBzdGF0ZW1lbnRzIGludG8gYXJyYXkgb2YgaW5kaXZpZHVhbCBzdGF0ZW1lbnRzLgogKgogKiBAcmV0dXJuIGFycmF5PHN0cmluZz4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":90,"slug":"sql-deparse-options","name":"sql_deparse_options","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"DeparseOptions","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBEZXBhcnNlT3B0aW9ucyBmb3IgY29uZmlndXJpbmcgU1FMIGZvcm1hdHRpbmcuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":104,"slug":"sql-deparse","name":"sql_deparse","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"DeparseOptions","namespace":"Flow\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBQYXJzZWRRdWVyeSBBU1QgYmFjayB0byBTUUwgc3RyaW5nLgogKgogKiBXaGVuIGNhbGxlZCB3aXRob3V0IG9wdGlvbnMsIHJldHVybnMgdGhlIFNRTCBhcyBhIHNpbXBsZSBzdHJpbmcuCiAqIFdoZW4gY2FsbGVkIHdpdGggRGVwYXJzZU9wdGlvbnMsIGFwcGxpZXMgZm9ybWF0dGluZyAocHJldHR5LXByaW50aW5nLCBpbmRlbnRhdGlvbiwgZXRjLikuCiAqCiAqIEB0aHJvd3MgXFJ1bnRpbWVFeGNlcHRpb24gaWYgZGVwYXJzaW5nIGZhaWxzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":120,"slug":"sql-format","name":"sql_format","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"DeparseOptions","namespace":"Flow\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcnNlIGFuZCBmb3JtYXQgU1FMIHF1ZXJ5IHdpdGggcHJldHR5IHByaW50aW5nLgogKgogKiBUaGlzIGlzIGEgY29udmVuaWVuY2UgZnVuY3Rpb24gdGhhdCBwYXJzZXMgU1FMIGFuZCByZXR1cm5zIGl0IGZvcm1hdHRlZC4KICoKICogQHBhcmFtIHN0cmluZyAkc3FsIFRoZSBTUUwgcXVlcnkgdG8gZm9ybWF0CiAqIEBwYXJhbSBudWxsfERlcGFyc2VPcHRpb25zICRvcHRpb25zIEZvcm1hdHRpbmcgb3B0aW9ucyAoZGVmYXVsdHMgdG8gcHJldHR5LXByaW50IGVuYWJsZWQpCiAqCiAqIEB0aHJvd3MgXFJ1bnRpbWVFeGNlcHRpb24gaWYgcGFyc2luZyBvciBkZXBhcnNpbmcgZmFpbHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":132,"slug":"sql-summary","name":"sql_summary","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"truncateLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdlbmVyYXRlIGEgc3VtbWFyeSBvZiBwYXJzZWQgcXVlcmllcyBpbiBwcm90b2J1ZiBmb3JtYXQuCiAqIFVzZWZ1bCBmb3IgcXVlcnkgbW9uaXRvcmluZyBhbmQgbG9nZ2luZyB3aXRob3V0IGZ1bGwgQVNUIG92ZXJoZWFkLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":147,"slug":"sql-to-paginated-query","name":"sql_to_paginated_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGEgcGFnaW5hdGVkIHF1ZXJ5IHdpdGggTElNSVQgYW5kIE9GRlNFVC4KICoKICogQHBhcmFtIHN0cmluZyAkc3FsIFRoZSBTUUwgcXVlcnkgdG8gcGFnaW5hdGUKICogQHBhcmFtIGludCAkbGltaXQgTWF4aW11bSBudW1iZXIgb2Ygcm93cyB0byByZXR1cm4KICogQHBhcmFtIGludCAkb2Zmc2V0IE51bWJlciBvZiByb3dzIHRvIHNraXAgKHJlcXVpcmVzIE9SREVSIEJZIGluIHF1ZXJ5KQogKgogKiBAcmV0dXJuIHN0cmluZyBUaGUgcGFnaW5hdGVkIFNRTCBxdWVyeQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":164,"slug":"sql-to-limited-query","name":"sql_to_limited_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSB0byBsaW1pdCByZXN1bHRzIHRvIGEgc3BlY2lmaWMgbnVtYmVyIG9mIHJvd3MuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJHNxbCBUaGUgU1FMIHF1ZXJ5IHRvIGxpbWl0CiAqIEBwYXJhbSBpbnQgJGxpbWl0IE1heGltdW0gbnVtYmVyIG9mIHJvd3MgdG8gcmV0dXJuCiAqCiAqIEByZXR1cm4gc3RyaW5nIFRoZSBsaW1pdGVkIFNRTCBxdWVyeQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":183,"slug":"sql-to-count-query","name":"sql_to_count_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGEgQ09VTlQgcXVlcnkgZm9yIHBhZ2luYXRpb24uCiAqCiAqIFdyYXBzIHRoZSBxdWVyeSBpbjogU0VMRUNUIENPVU5UKCopIEZST00gKC4uLikgQVMgX2NvdW50X3N1YnEKICogUmVtb3ZlcyBPUkRFUiBCWSBhbmQgTElNSVQvT0ZGU0VUIGZyb20gdGhlIGlubmVyIHF1ZXJ5LgogKgogKiBAcGFyYW0gc3RyaW5nICRzcWwgVGhlIFNRTCBxdWVyeSB0byB0cmFuc2Zvcm0KICoKICogQHJldHVybiBzdHJpbmcgVGhlIENPVU5UIHF1ZXJ5CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":205,"slug":"sql-to-keyset-query","name":"sql_to_keyset_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"cursor","type":[{"name":"array","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGEga2V5c2V0IChjdXJzb3ItYmFzZWQpIHBhZ2luYXRlZCBxdWVyeS4KICoKICogTW9yZSBlZmZpY2llbnQgdGhhbiBPRkZTRVQgZm9yIGxhcmdlIGRhdGFzZXRzIC0gdXNlcyBpbmRleGVkIFdIRVJFIGNvbmRpdGlvbnMuCiAqIEF1dG9tYXRpY2FsbHkgZGV0ZWN0cyBleGlzdGluZyBxdWVyeSBwYXJhbWV0ZXJzIGFuZCBhcHBlbmRzIGtleXNldCBwbGFjZWhvbGRlcnMgYXQgdGhlIGVuZC4KICoKICogQHBhcmFtIHN0cmluZyAkc3FsIFRoZSBTUUwgcXVlcnkgdG8gcGFnaW5hdGUgKE9SREVSIEJZIG9wdGlvbmFsOyB3aGVuIHByZXNlbnQgaXQgbXVzdCBlcXVhbCB0aGUga2V5czsgbm8gTElNSVQvT0ZGU0VUKQogKiBAcGFyYW0gaW50ICRsaW1pdCBNYXhpbXVtIG51bWJlciBvZiByb3dzIHRvIHJldHVybgogKiBAcGFyYW0gbGlzdDxLZXlzZXRDb2x1bW4+ICRjb2x1bW5zIENvbHVtbnMgZm9yIGtleXNldCBwYWdpbmF0aW9uIChtdXN0IG1hdGNoIE9SREVSIEJZKQogKiBAcGFyYW0gbnVsbHxsaXN0PGJvb2x8ZmxvYXR8aW50fHN0cmluZz4gJGN1cnNvciBWYWx1ZXMgZnJvbSBsYXN0IHJvdyBvZiBwcmV2aW91cyBwYWdlIChudWxsIGZvciBmaXJzdCBwYWdlKQogKgogKiBAcmV0dXJuIHN0cmluZyBUaGUgcGFnaW5hdGVkIFNRTCBxdWVyeQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":220,"slug":"sql-keyset-column","name":"sql_keyset_column","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\AST\\Transformers\\SortOrder::..."}],"return_type":[{"name":"KeysetColumn","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEtleXNldENvbHVtbiBmb3Iga2V5c2V0IHBhZ2luYXRpb24uCiAqCiAqIEBwYXJhbSBzdHJpbmcgJGNvbHVtbiBDb2x1bW4gbmFtZSAoY2FuIGluY2x1ZGUgdGFibGUgYWxpYXMgbGlrZSAidS5pZCIpCiAqIEBwYXJhbSBTb3J0T3JkZXIgJG9yZGVyIFNvcnQgb3JkZXIgKEFTQyBvciBERVNDKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":229,"slug":"sql-query-columns","name":"sql_query_columns","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Columns","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgY29sdW1ucyBmcm9tIGEgcGFyc2VkIFNRTCBxdWVyeS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":238,"slug":"sql-query-tables","name":"sql_query_tables","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Tables","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgdGFibGVzIGZyb20gYSBwYXJzZWQgU1FMIHF1ZXJ5LgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":247,"slug":"sql-query-functions","name":"sql_query_functions","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Functions","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgZnVuY3Rpb25zIGZyb20gYSBwYXJzZWQgU1FMIHF1ZXJ5LgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":256,"slug":"sql-query-order-by","name":"sql_query_order_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgT1JERVIgQlkgY2xhdXNlcyBmcm9tIGEgcGFyc2VkIFNRTCBxdWVyeS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":270,"slug":"sql-query-depth","name":"sql_query_depth","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgbWF4aW11bSBuZXN0aW5nIGRlcHRoIG9mIGEgU1FMIHF1ZXJ5LgogKgogKiBFeGFtcGxlOgogKiAtICJTRUxFQ1QgKiBGUk9NIHQiID0+IDEKICogLSAiU0VMRUNUICogRlJPTSAoU0VMRUNUICogRlJPTSB0KSIgPT4gMgogKiAtICJTRUxFQ1QgKiBGUk9NIChTRUxFQ1QgKiBGUk9NIChTRUxFQ1QgKiBGUk9NIHQpKSIgPT4gMwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":287,"slug":"sql-to-explain","name":"sql_to_explain","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"config","type":[{"name":"ExplainConfig","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGFuIEVYUExBSU4gcXVlcnkuCiAqCiAqIFJldHVybnMgdGhlIG1vZGlmaWVkIFNRTCB3aXRoIEVYUExBSU4gd3JhcHBlZCBhcm91bmQgaXQuCiAqIERlZmF1bHRzIHRvIEVYUExBSU4gQU5BTFlaRSB3aXRoIEpTT04gZm9ybWF0IGZvciBlYXN5IHBhcnNpbmcuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJHNxbCBUaGUgU1FMIHF1ZXJ5IHRvIGV4cGxhaW4KICogQHBhcmFtIG51bGx8RXhwbGFpbkNvbmZpZyAkY29uZmlnIEVYUExBSU4gY29uZmlndXJhdGlvbiAoZGVmYXVsdHMgdG8gZm9yQW5hbHlzaXMoKSkKICoKICogQHJldHVybiBzdHJpbmcgVGhlIEVYUExBSU4gcXVlcnkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":307,"slug":"sql-explain-config","name":"sql_explain_config","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"analyze","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"verbose","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"costs","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"buffers","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"timing","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"format","type":[{"name":"ExplainFormat","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Utility\\ExplainFormat::..."}],"return_type":[{"name":"ExplainConfig","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFeHBsYWluQ29uZmlnIGZvciBjdXN0b21pemluZyBFWFBMQUlOIG9wdGlvbnMuCiAqCiAqIEBwYXJhbSBib29sICRhbmFseXplIFdoZXRoZXIgdG8gYWN0dWFsbHkgZXhlY3V0ZSB0aGUgcXVlcnkgKEFOQUxZWkUpCiAqIEBwYXJhbSBib29sICR2ZXJib3NlIEluY2x1ZGUgdmVyYm9zZSBvdXRwdXQKICogQHBhcmFtIGJvb2wgJGNvc3RzIEluY2x1ZGUgY29zdCBlc3RpbWF0ZXMgKGRlZmF1bHQgdHJ1ZSkKICogQHBhcmFtIGJvb2wgJGJ1ZmZlcnMgSW5jbHVkZSBidWZmZXIgdXNhZ2Ugc3RhdGlzdGljcyAocmVxdWlyZXMgYW5hbHl6ZSkKICogQHBhcmFtIGJvb2wgJHRpbWluZyBJbmNsdWRlIHRpbWluZyBpbmZvcm1hdGlvbiAocmVxdWlyZXMgYW5hbHl6ZSkKICogQHBhcmFtIEV4cGxhaW5Gb3JtYXQgJGZvcm1hdCBPdXRwdXQgZm9ybWF0IChKU09OIHJlY29tbWVuZGVkIGZvciBwYXJzaW5nKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":329,"slug":"sql-explain-modifier","name":"sql_explain_modifier","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"config","type":[{"name":"ExplainConfig","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExplainModifier","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFeHBsYWluTW9kaWZpZXIgZm9yIHRyYW5zZm9ybWluZyBxdWVyaWVzIGludG8gRVhQTEFJTiBxdWVyaWVzLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":342,"slug":"sql-explain-parse","name":"sql_explain_parse","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"jsonOutput","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Plan","namespace":"Flow\\PostgreSql\\Explain\\Plan","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcnNlIEVYUExBSU4gSlNPTiBvdXRwdXQgaW50byBhIFBsYW4gb2JqZWN0LgogKgogKiBAcGFyYW0gc3RyaW5nICRqc29uT3V0cHV0IFRoZSBKU09OIG91dHB1dCBmcm9tIEVYUExBSU4gKEZPUk1BVCBKU09OKQogKgogKiBAcmV0dXJuIFBsYW4gVGhlIHBhcnNlZCBleGVjdXRpb24gcGxhbgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":355,"slug":"sql-analyze","name":"sql_analyze","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"plan","type":[{"name":"Plan","namespace":"Flow\\PostgreSql\\Explain\\Plan","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PlanAnalyzer","namespace":"Flow\\PostgreSql\\Explain\\Analyzer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHBsYW4gYW5hbHl6ZXIgZm9yIGFuYWx5emluZyBFWFBMQUlOIHBsYW5zLgogKgogKiBAcGFyYW0gUGxhbiAkcGxhbiBUaGUgZXhlY3V0aW9uIHBsYW4gdG8gYW5hbHl6ZQogKgogKiBAcmV0dXJuIFBsYW5BbmFseXplciBUaGUgYW5hbHl6ZXIgZm9yIGV4dHJhY3RpbmcgaW5zaWdodHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":46,"slug":"pgsql-connection","name":"pgsql_connection","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"connectionString","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjb25uZWN0aW9uIHBhcmFtZXRlcnMgZnJvbSBhIGNvbm5lY3Rpb24gc3RyaW5nLgogKgogKiBBY2NlcHRzIGxpYnBxLXN0eWxlIGNvbm5lY3Rpb24gc3RyaW5nczoKICogLSBLZXktdmFsdWUgZm9ybWF0OiAiaG9zdD1sb2NhbGhvc3QgcG9ydD01NDMyIGRibmFtZT1teWRiIHVzZXI9bXl1c2VyIHBhc3N3b3JkPXNlY3JldCIKICogLSBVUkkgZm9ybWF0OiAicG9zdGdyZXNxbDovL3VzZXI6cGFzc3dvcmRAbG9jYWxob3N0OjU0MzIvZGJuYW1lIgogKgogKiBAZXhhbXBsZQogKiAkcGFyYW1zID0gcGdzcWxfY29ubmVjdGlvbignaG9zdD1sb2NhbGhvc3QgZGJuYW1lPW15ZGInKTsKICogJHBhcmFtcyA9IHBnc3FsX2Nvbm5lY3Rpb24oJ3Bvc3RncmVzcWw6Ly91c2VyOnBhc3NAbG9jYWxob3N0L215ZGInKTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":68,"slug":"pgsql-connection-dsn","name":"pgsql_connection_dsn","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"dsn","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjb25uZWN0aW9uIHBhcmFtZXRlcnMgZnJvbSBhIERTTiBzdHJpbmcuCiAqCiAqIFBhcnNlcyBzdGFuZGFyZCBQb3N0Z3JlU1FMIERTTiBmb3JtYXQgY29tbW9ubHkgdXNlZCBpbiBlbnZpcm9ubWVudCB2YXJpYWJsZXMKICogKGUuZy4sIERBVEFCQVNFX1VSTCkuIFN1cHBvcnRzIHBvc3RncmVzOi8vLCBwb3N0Z3Jlc3FsOi8vLCBhbmQgcGdzcWw6Ly8gc2NoZW1lcy4KICoKICogQHBhcmFtIHN0cmluZyAkZHNuIERTTiBzdHJpbmcgaW4gZm9ybWF0OiBwb3N0Z3JlczovL3VzZXI6cGFzc3dvcmRAaG9zdDpwb3J0L2RhdGFiYXNlP29wdGlvbnMKICoKICogQHRocm93cyBDbGllbnRcRHNuUGFyc2VyRXhjZXB0aW9uIElmIHRoZSBEU04gY2Fubm90IGJlIHBhcnNlZAogKgogKiBAZXhhbXBsZQogKiAkcGFyYW1zID0gcGdzcWxfY29ubmVjdGlvbl9kc24oJ3Bvc3RncmVzOi8vbXl1c2VyOnNlY3JldEBsb2NhbGhvc3Q6NTQzMi9teWRiJyk7CiAqICRwYXJhbXMgPSBwZ3NxbF9jb25uZWN0aW9uX2RzbigncG9zdGdyZXNxbDovL3VzZXI6cGFzc0BkYi5leGFtcGxlLmNvbS9hcHA\/c3NsbW9kZT1yZXF1aXJlJyk7CiAqICRwYXJhbXMgPSBwZ3NxbF9jb25uZWN0aW9uX2RzbigncGdzcWw6Ly91c2VyOnBhc3NAbG9jYWxob3N0L215ZGInKTsgLy8gU3ltZm9ueS9Eb2N0cmluZSBmb3JtYXQKICogJHBhcmFtcyA9IHBnc3FsX2Nvbm5lY3Rpb25fZHNuKGdldGVudignREFUQUJBU0VfVVJMJykpOwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":95,"slug":"pgsql-connection-params","name":"pgsql_connection_params","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"database","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'localhost'"},{"name":"port","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"5432"},{"name":"user","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"password","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjb25uZWN0aW9uIHBhcmFtZXRlcnMgZnJvbSBpbmRpdmlkdWFsIHZhbHVlcy4KICoKICogQWxsb3dzIHNwZWNpZnlpbmcgY29ubmVjdGlvbiBwYXJhbWV0ZXJzIGluZGl2aWR1YWxseSBmb3IgYmV0dGVyIHR5cGUgc2FmZXR5CiAqIGFuZCBJREUgc3VwcG9ydC4KICoKICogQHBhcmFtIHN0cmluZyAkZGF0YWJhc2UgRGF0YWJhc2UgbmFtZSAocmVxdWlyZWQpCiAqIEBwYXJhbSBzdHJpbmcgJGhvc3QgSG9zdG5hbWUgKGRlZmF1bHQ6IGxvY2FsaG9zdCkKICogQHBhcmFtIGludCAkcG9ydCBQb3J0IG51bWJlciAoZGVmYXVsdDogNTQzMikKICogQHBhcmFtIG51bGx8c3RyaW5nICR1c2VyIFVzZXJuYW1lIChvcHRpb25hbCkKICogQHBhcmFtIG51bGx8c3RyaW5nICRwYXNzd29yZCBQYXNzd29yZCAob3B0aW9uYWwpCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIHN0cmluZz4gJG9wdGlvbnMgQWRkaXRpb25hbCBsaWJwcSBvcHRpb25zCiAqCiAqIEBleGFtcGxlCiAqICRwYXJhbXMgPSBwZ3NxbF9jb25uZWN0aW9uX3BhcmFtcygKICogICAgIGRhdGFiYXNlOiAnbXlkYicsCiAqICAgICBob3N0OiAnbG9jYWxob3N0JywKICogICAgIHVzZXI6ICdteXVzZXInLAogKiAgICAgcGFzc3dvcmQ6ICdzZWNyZXQnLAogKiApOwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":126,"slug":"pgsql-client","name":"pgsql_client","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"params","type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"valueConverters","type":[{"name":"ValueConverters","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"context","type":[{"name":"Context","namespace":"Flow\\PostgreSql\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgY2xpZW50IHVzaW5nIGV4dC1wZ3NxbC4KICoKICogVGhlIGNsaWVudCBjb25uZWN0cyBpbW1lZGlhdGVseSBhbmQgaXMgcmVhZHkgdG8gZXhlY3V0ZSBxdWVyaWVzLgogKgogKiBAcGFyYW0gQ2xpZW50XENvbm5lY3Rpb25QYXJhbWV0ZXJzICRwYXJhbXMgQ29ubmVjdGlvbiBwYXJhbWV0ZXJzCiAqIEBwYXJhbSBudWxsfFZhbHVlQ29udmVydGVycyAkdmFsdWVDb252ZXJ0ZXJzIEN1c3RvbSB0eXBlIGNvbnZlcnRlcnMgKG9wdGlvbmFsKQogKiBAcGFyYW0gbnVsbHxDb250ZXh0ICRjb250ZXh0IEJhc2UgbWFwcGVyIENvbnRleHQg4oCUIHRoZSBDbGllbnQgZW5yaWNoZXMgaXQgd2l0aCBzcWwvcGFyYW1ldGVycy9zZWxmIHBlciBxdWVyeSBiZWZvcmUgaGFuZGluZyBpdCB0byBSb3dNYXBwZXI6Om1hcCgpCiAqCiAqIEB0aHJvd3MgQ29ubmVjdGlvbkV4Y2VwdGlvbiBJZiBjb25uZWN0aW9uIGZhaWxzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":143,"slug":"postgresql-context","name":"postgresql_context","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"catalog","type":[{"name":"Catalog","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Context","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJvd01hcHBlciBDb250ZXh0IHNlZWRlZCB3aXRoIHVzZXItc3VwcGxpZWQga2V5L3ZhbHVlIGRhdGEgYW5kIGFuIG9wdGlvbmFsIENhdGFsb2cuCiAqCiAqIFRoZSBDb250ZXh0IGlzIGxhdGVyIGVucmljaGVkIHdpdGggYSBRdWVyeSAoc3FsICsgcGFyYW1ldGVycykgYW5kIHRoZSBleGVjdXRpbmcgQ2xpZW50IGJ5IHRoZQogKiBQb3N0Z3JlU1FMIENsaWVudCBiZWZvcmUgYmVpbmcgaGFuZGVkIHRvIFJvd01hcHBlcjo6bWFwKCkuCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPiAkZGF0YSBVc2VyLXN1cHBsaWVkIGtleS92YWx1ZSBwYWlycwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":176,"slug":"postgresql-telemetry-options","name":"postgresql_telemetry_options","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"traceQueries","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"transactionSpans","type":[{"name":"TransactionSpanMode","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\Client\\Telemetry\\TransactionSpanMode::..."},{"name":"collectMetrics","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"logQueries","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"maxQueryLength","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"1000"},{"name":"includeParameters","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"maxParameters","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"10"},{"name":"maxParameterLength","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"100"}],"return_type":[{"name":"PostgreSqlTelemetryOptions","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB0ZWxlbWV0cnkgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBjbGllbnQgaW5zdHJ1bWVudGF0aW9uLgogKgogKiBDb250cm9scyB3aGljaCB0ZWxlbWV0cnkgc2lnbmFscyAodHJhY2VzLCBtZXRyaWNzLCBsb2dzKSBhcmUgZW5hYmxlZAogKiBhbmQgaG93IHF1ZXJ5IGluZm9ybWF0aW9uIGlzIGNhcHR1cmVkLgogKgogKiBAcGFyYW0gYm9vbCAkdHJhY2VRdWVyaWVzIENyZWF0ZSBzcGFucyBmb3IgcXVlcnkgZXhlY3V0aW9uIChkZWZhdWx0OiB0cnVlKQogKiBAcGFyYW0gVHJhbnNhY3Rpb25TcGFuTW9kZSAkdHJhbnNhY3Rpb25TcGFucyBIb3cgdHJhbnNhY3Rpb25zIGFyZSB0cmFjZWQ6IEdST1VQRUQgKGRlZmF1bHQpLCBQRVJfT1BFUkFUSU9OIG9yIE9GRgogKiBAcGFyYW0gYm9vbCAkY29sbGVjdE1ldHJpY3MgQ29sbGVjdCBkdXJhdGlvbiBhbmQgcm93IGNvdW50IG1ldHJpY3MgKGRlZmF1bHQ6IHRydWUpCiAqIEBwYXJhbSBib29sICRsb2dRdWVyaWVzIExvZyBleGVjdXRlZCBxdWVyaWVzIChkZWZhdWx0OiBmYWxzZSkKICogQHBhcmFtIG51bGx8aW50ICRtYXhRdWVyeUxlbmd0aCBNYXhpbXVtIHF1ZXJ5IHRleHQgbGVuZ3RoIGluIHRlbGVtZXRyeSAoZGVmYXVsdDogMTAwMCwgbnVsbCA9IHVubGltaXRlZCkKICogQHBhcmFtIGJvb2wgJGluY2x1ZGVQYXJhbWV0ZXJzIEluY2x1ZGUgcXVlcnkgcGFyYW1ldGVycyBpbiB0ZWxlbWV0cnkgKGRlZmF1bHQ6IGZhbHNlLCBzZWN1cml0eSBjb25zaWRlcmF0aW9uKQogKgogKiBAZXhhbXBsZQogKiAvLyBEZWZhdWx0IG9wdGlvbnMgKHRyYWNlcyBhbmQgbWV0cmljcyBlbmFibGVkKQogKiAkb3B0aW9ucyA9IHBvc3RncmVzcWxfdGVsZW1ldHJ5X29wdGlvbnMoKTsKICoKICogLy8gRW5hYmxlIHF1ZXJ5IGxvZ2dpbmcKICogJG9wdGlvbnMgPSBwb3N0Z3Jlc3FsX3RlbGVtZXRyeV9vcHRpb25zKGxvZ1F1ZXJpZXM6IHRydWUpOwogKgogKiAvLyBNZXRyaWNzIG9ubHksIG5vIHNwYW5zCiAqICRvcHRpb25zID0gcG9zdGdyZXNxbF90ZWxlbWV0cnlfb3B0aW9ucygKICogICAgIHRyYWNlUXVlcmllczogZmFsc2UsCiAqICAgICB0cmFuc2FjdGlvblNwYW5zOiBUcmFuc2FjdGlvblNwYW5Nb2RlOjpPRkYsCiAqICAgICBjb2xsZWN0TWV0cmljczogdHJ1ZSwKICogKTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":214,"slug":"postgresql-telemetry-config","name":"postgresql_telemetry_config","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"telemetry","type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"PostgreSqlTelemetryOptions","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PostgreSqlTelemetryConfig","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB0ZWxlbWV0cnkgY29uZmlndXJhdGlvbiBmb3IgUG9zdGdyZVNRTCBjbGllbnQuCiAqCiAqIEJ1bmRsZXMgdGVsZW1ldHJ5IGluc3RhbmNlLCBjbG9jaywgYW5kIG9wdGlvbnMgbmVlZGVkIHRvIGluc3RydW1lbnQgYSBQb3N0Z3JlU1FMIGNsaWVudC4KICoKICogQHBhcmFtIFRlbGVtZXRyeSAkdGVsZW1ldHJ5IFRoZSB0ZWxlbWV0cnkgaW5zdGFuY2UKICogQHBhcmFtIENsb2NrSW50ZXJmYWNlICRjbG9jayBDbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gbnVsbHxQb3N0Z3JlU3FsVGVsZW1ldHJ5T3B0aW9ucyAkb3B0aW9ucyBUZWxlbWV0cnkgb3B0aW9ucyAoZGVmYXVsdDogYWxsIGVuYWJsZWQpCiAqCiAqIEBleGFtcGxlCiAqICRjb25maWcgPSBwb3N0Z3Jlc3FsX3RlbGVtZXRyeV9jb25maWcoCiAqICAgICB0ZWxlbWV0cnkocmVzb3VyY2UoWydzZXJ2aWNlLm5hbWUnID0+ICdteS1hcHAnXSkpLAogKiAgICAgbmV3IFN5c3RlbUNsb2NrKCksCiAqICk7CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":260,"slug":"traceable-postgresql-client","name":"traceable_postgresql_client","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"telemetryConfig","type":[{"name":"PostgreSqlTelemetryConfig","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TraceableClient","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYSBQb3N0Z3JlU1FMIGNsaWVudCB3aXRoIHRlbGVtZXRyeSBpbnN0cnVtZW50YXRpb24uCiAqCiAqIFJldHVybnMgYSBkZWNvcmF0b3IgdGhhdCBhZGRzIHNwYW5zLCBtZXRyaWNzLCBhbmQgbG9ncyB0byBhbGwKICogcXVlcnkgYW5kIHRyYW5zYWN0aW9uIG9wZXJhdGlvbnMgZm9sbG93aW5nIE9wZW5UZWxlbWV0cnkgY29udmVudGlvbnMuCiAqCiAqIEBwYXJhbSBDbGllbnRcQ2xpZW50ICRjbGllbnQgVGhlIFBvc3RncmVTUUwgY2xpZW50IHRvIGluc3RydW1lbnQKICogQHBhcmFtIFBvc3RncmVTcWxUZWxlbWV0cnlDb25maWcgJHRlbGVtZXRyeUNvbmZpZyBUZWxlbWV0cnkgY29uZmlndXJhdGlvbgogKgogKiBAZXhhbXBsZQogKiAkY2xpZW50ID0gcGdzcWxfY2xpZW50KHBnc3FsX2Nvbm5lY3Rpb24oJ2hvc3Q9bG9jYWxob3N0IGRibmFtZT1teWRiJykpOwogKgogKiAkdHJhY2VhYmxlQ2xpZW50ID0gdHJhY2VhYmxlX3Bvc3RncmVzcWxfY2xpZW50KAogKiAgICAgJGNsaWVudCwKICogICAgIHBvc3RncmVzcWxfdGVsZW1ldHJ5X2NvbmZpZygKICogICAgICAgICB0ZWxlbWV0cnkocmVzb3VyY2UoWydzZXJ2aWNlLm5hbWUnID0+ICdteS1hcHAnXSkpLAogKiAgICAgICAgIG5ldyBTeXN0ZW1DbG9jaygpLAogKiAgICAgICAgIHBvc3RncmVzcWxfdGVsZW1ldHJ5X29wdGlvbnMoCiAqICAgICAgICAgICAgIHRyYWNlUXVlcmllczogdHJ1ZSwKICogICAgICAgICAgICAgdHJhbnNhY3Rpb25TcGFuczogVHJhbnNhY3Rpb25TcGFuTW9kZTo6R1JPVVBFRCwKICogICAgICAgICAgICAgY29sbGVjdE1ldHJpY3M6IHRydWUsCiAqICAgICAgICAgICAgIGxvZ1F1ZXJpZXM6IHRydWUsCiAqICAgICAgICAgICAgIG1heFF1ZXJ5TGVuZ3RoOiA1MDAsCiAqICAgICAgICAgKSwKICogICAgICksCiAqICk7CiAqCiAqIC8vIEFsbCBvcGVyYXRpb25zIG5vdyB0cmFjZWQKICogJHRyYWNlYWJsZUNsaWVudC0+dHJhbnNhY3Rpb24oZnVuY3Rpb24gKENsaWVudCAkY2xpZW50KSB7CiAqICAgICAkdXNlciA9ICRjbGllbnQtPmZldGNoU2luZ2xlKCdTRUxFQ1QgKiBGUk9NIHVzZXJzIFdIRVJFIGlkID0gJDEnLCBbMTIzXSk7CiAqICAgICAkY2xpZW50LT5leGVjdXRlKCdVUERBVEUgdXNlcnMgU0VUIGxhc3RfbG9naW4gPSBOT1coKSBXSEVSRSBpZCA9ICQxJywgWzEyM10pOwogKiB9KTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":300,"slug":"constructor-mapper","name":"constructor_mapper","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConstructorMapper","namespace":"Flow\\PostgreSql\\Client\\RowMapper","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICRjbGFzcwogKgogKiBAcmV0dXJuIENvbnN0cnVjdG9yTWFwcGVyPFQ+CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":315,"slug":"type-mapper","name":"type_mapper","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"next","type":[{"name":"RowMapper","namespace":"Flow\\PostgreSql\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TypeMapper","namespace":"Flow\\PostgreSql\\Client\\RowMapper","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUVHlwZQogKiBAdGVtcGxhdGUgVE91dAogKgogKiBAcGFyYW0gRmxvd1R5cGU8VFR5cGU+ICR0eXBlCiAqIEBwYXJhbSBudWxsfFJvd01hcHBlcjxUT3V0PiAkbmV4dAogKgogKiBAcmV0dXJuICgkbmV4dCBpcyBudWxsID8gVHlwZU1hcHBlcjxUVHlwZSwgVFR5cGU+IDogVHlwZU1hcHBlcjxUVHlwZSwgVE91dD4pCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":343,"slug":"static-factory-mapper","name":"static_factory_mapper","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"method","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StaticFactoryMapper","namespace":"Flow\\PostgreSql\\Client\\RowMapper","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJvdyBtYXBwZXIgYmFja2VkIGJ5IGEgcHVibGljIHN0YXRpYyBmYWN0b3J5IG1ldGhvZC4KICoKICogVGhlIGZhY3RvcnkgbWV0aG9kIG11c3QgYWNjZXB0IGEgc2luZ2xlIGFycmF5PHN0cmluZywgbWl4ZWQ+ICRyb3cgYW5kIHJldHVybgogKiBhbiBpbnN0YW5jZSBvZiB0aGUgdGFyZ2V0IGNsYXNzLiBJZiB5b3VyIGZhY3RvcnkgbmVlZHMgYWNjZXNzIHRvIHRoZSBtYXBwaW5nCiAqIENvbnRleHQgKHNxbC9wYXJhbWV0ZXJzL2NsaWVudC9jYXRhbG9nL3VzZXItZGF0YSksIGltcGxlbWVudCBSb3dNYXBwZXIgZGlyZWN0bHkuCiAqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICRjbGFzcwogKiBAcGFyYW0gbm9uLWVtcHR5LXN0cmluZyAkbWV0aG9kCiAqCiAqIEByZXR1cm4gU3RhdGljRmFjdG9yeU1hcHBlcjxUPgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":372,"slug":"typed","name":"typed","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"targetType","type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TypedValue","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYSB2YWx1ZSB3aXRoIGV4cGxpY2l0IFBvc3RncmVTUUwgdHlwZSBpbmZvcm1hdGlvbiBmb3IgcGFyYW1ldGVyIGJpbmRpbmcuCiAqCiAqIFVzZSB3aGVuIGF1dG8tZGV0ZWN0aW9uIGlzbid0IHN1ZmZpY2llbnQgb3Igd2hlbiB5b3UgbmVlZCB0byBzcGVjaWZ5CiAqIHRoZSBleGFjdCBQb3N0Z3JlU1FMIHR5cGUgKHNpbmNlIG9uZSBQSFAgdHlwZSBjYW4gbWFwIHRvIG11bHRpcGxlIFBvc3RncmVTUUwgdHlwZXMpOgogKiAtIGludCBjb3VsZCBiZSBJTlQyLCBJTlQ0LCBvciBJTlQ4CiAqIC0gc3RyaW5nIGNvdWxkIGJlIFRFWFQsIFZBUkNIQVIsIG9yIENIQVIKICogLSBhcnJheSBtdXN0IGFsd2F5cyB1c2UgdHlwZWQoKSBzaW5jZSBhdXRvLWRldGVjdGlvbiBjYW5ub3QgZGV0ZXJtaW5lIGVsZW1lbnQgdHlwZQogKiAtIERhdGVUaW1lSW50ZXJmYWNlIGNvdWxkIGJlIFRJTUVTVEFNUCBvciBUSU1FU1RBTVBUWgogKiAtIEpzb24gY291bGQgYmUgSlNPTiBvciBKU09OQgogKgogKiBAcGFyYW0gbWl4ZWQgJHZhbHVlIFRoZSB2YWx1ZSB0byBiaW5kCiAqIEBwYXJhbSBWYWx1ZVR5cGUgJHRhcmdldFR5cGUgVGhlIFBvc3RncmVTUUwgdHlwZSB0byBjb252ZXJ0IHRoZSB2YWx1ZSB0bwogKgogKiBAZXhhbXBsZQogKiAkY2xpZW50LT5mZXRjaCgKICogICAgICdTRUxFQ1QgKiBGUk9NIHVzZXJzIFdIRVJFIGlkID0gJDEgQU5EIHRhZ3MgPSAkMicsCiAqICAgICBbCiAqICAgICAgICAgdHlwZWQoJzU1MGU4NDAwLWUyOWItNDFkNC1hNzE2LTQ0NjY1NTQ0MDAwMCcsIFZhbHVlVHlwZTo6VVVJRCksCiAqICAgICAgICAgdHlwZWQoWyd0YWcxJywgJ3RhZzInXSwgVmFsdWVUeXBlOjpURVhUX0FSUkFZKSwKICogICAgIF0KICogKTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":386,"slug":"converted-parameters","name":"converted_parameters","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"values","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConvertedParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcmFtZXRlcnMgYWxyZWFkeSBpbiBQb3N0Z3JlU1FMJ3MgdGV4dCBmb3JtLCB3aGljaCBDbGllbnQ6OmV4ZWN1dGUoKSBzZW5kcyB3aXRob3V0IHJ1bm5pbmcgYSBjb252ZXJ0ZXIuCiAqCiAqIEBwYXJhbSBsaXN0PG51bGx8c3RyaW5nPiAkdmFsdWVzCiAqCiAqIEBleGFtcGxlCiAqICRjbGllbnQtPmV4ZWN1dGUoJ1VQREFURSB1c2VycyBTRVQgYWN0aXZlID0gJDEgV0hFUkUgaWQgPSAkMicsIGNvbnZlcnRlZF9wYXJhbWV0ZXJzKFsnZicsICcxJ10pKTsKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":126,"slug":"trace-id","name":"trace_id","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"hex","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TraceId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlSWQuCiAqCiAqIElmIGEgaGV4IHN0cmluZyBpcyBwcm92aWRlZCwgY3JlYXRlcyBhIFRyYWNlSWQgZnJvbSBpdC4KICogT3RoZXJ3aXNlLCBnZW5lcmF0ZXMgYSBuZXcgcmFuZG9tIFRyYWNlSWQuCiAqCiAqIEBwYXJhbSBudWxsfHN0cmluZyAkaGV4IE9wdGlvbmFsIDMyLWNoYXJhY3RlciBoZXhhZGVjaW1hbCBzdHJpbmcKICoKICogQHRocm93cyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBoZXggc3RyaW5nIGlzIGludmFsaWQKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":146,"slug":"span-id","name":"span_id","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"hex","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SpanId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5JZC4KICoKICogSWYgYSBoZXggc3RyaW5nIGlzIHByb3ZpZGVkLCBjcmVhdGVzIGEgU3BhbklkIGZyb20gaXQuCiAqIE90aGVyd2lzZSwgZ2VuZXJhdGVzIGEgbmV3IHJhbmRvbSBTcGFuSWQuCiAqCiAqIEBwYXJhbSBudWxsfHN0cmluZyAkaGV4IE9wdGlvbmFsIDE2LWNoYXJhY3RlciBoZXhhZGVjaW1hbCBzdHJpbmcKICoKICogQHRocm93cyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBoZXggc3RyaW5nIGlzIGludmFsaWQKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":161,"slug":"baggage","name":"baggage","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"entries","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Baggage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhZ2dhZ2UuCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIHN0cmluZz4gJGVudHJpZXMgSW5pdGlhbCBrZXktdmFsdWUgZW50cmllcwogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":175,"slug":"context","name":"context","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"baggage","type":[{"name":"Baggage","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Context","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJvb3QgQ29udGV4dCAobm8gYWN0aXZlIHNwYW4pLgogKgogKiBBIHNwYW4gY3JlYXRlZCBpbiB0aGlzIGNvbnRleHQgYmVjb21lcyBhIG5ldyB0cmFjZSByb290LiBBdHRhY2ggYW4gYWN0aXZlIHNwYW4gd2l0aAogKiBDb250ZXh0Ojp3aXRoQWN0aXZlU3BhbigpIHRvIG1ha2Ugc3Vic2VxdWVudCBzcGFucyBpdHMgY2hpbGRyZW4uCiAqCiAqIEBwYXJhbSBudWxsfEJhZ2dhZ2UgJGJhZ2dhZ2UgT3B0aW9uYWwgQmFnZ2FnZSB0byB1c2UKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":189,"slug":"memory-context-storage","name":"memory_context_storage","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"context","type":[{"name":"Context","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MemoryContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeUNvbnRleHRTdG9yYWdlLgogKgogKiBJbi1tZW1vcnkgY29udGV4dCBzdG9yYWdlIGZvciBzdG9yaW5nIGFuZCByZXRyaWV2aW5nIHRoZSBjdXJyZW50IGNvbnRleHQuCiAqIEEgc2luZ2xlIGluc3RhbmNlIHNob3VsZCBiZSBzaGFyZWQgYWNyb3NzIGFsbCBwcm92aWRlcnMgd2l0aGluIGEgcmVxdWVzdCBsaWZlY3ljbGUuCiAqCiAqIEBwYXJhbSBudWxsfENvbnRleHQgJGNvbnRleHQgT3B0aW9uYWwgaW5pdGlhbCBjb250ZXh0CiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":200,"slug":"resource","name":"resource","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Resource","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJlc291cmNlLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBhcnJheTxhcnJheS1rZXksIG1peGVkPnxib29sfFxEYXRlVGltZUludGVyZmFjZXxmbG9hdHxpbnR8c3RyaW5nfFxUaHJvd2FibGU+fEF0dHJpYnV0ZXMgJGF0dHJpYnV0ZXMgUmVzb3VyY2UgYXR0cmlidXRlcwogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":213,"slug":"span-context","name":"span_context","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"traceId","type":[{"name":"TraceId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"spanId","type":[{"name":"SpanId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parentSpanId","type":[{"name":"SpanId","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SpanContext","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5Db250ZXh0LgogKgogKiBAcGFyYW0gVHJhY2VJZCAkdHJhY2VJZCBUaGUgdHJhY2UgSUQKICogQHBhcmFtIFNwYW5JZCAkc3BhbklkIFRoZSBzcGFuIElECiAqIEBwYXJhbSBudWxsfFNwYW5JZCAkcGFyZW50U3BhbklkIE9wdGlvbmFsIHBhcmVudCBzcGFuIElECiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":226,"slug":"span-event","name":"span_event","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"timestamp","type":[{"name":"DateTimeImmutable","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"GenericEvent","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5FdmVudCAoR2VuZXJpY0V2ZW50KSB3aXRoIGFuIGV4cGxpY2l0IHRpbWVzdGFtcC4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBFdmVudCBuYW1lCiAqIEBwYXJhbSBcRGF0ZVRpbWVJbW11dGFibGUgJHRpbWVzdGFtcCBFdmVudCB0aW1lc3RhbXAKICogQHBhcmFtIGFycmF5PHN0cmluZywgYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58Ym9vbHxcRGF0ZVRpbWVJbnRlcmZhY2V8ZmxvYXR8aW50fHN0cmluZ3xcVGhyb3dhYmxlPnxBdHRyaWJ1dGVzICRhdHRyaWJ1dGVzIEV2ZW50IGF0dHJpYnV0ZXMKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":238,"slug":"span-link","name":"span_link","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"context","type":[{"name":"SpanContext","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"SpanLink","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5MaW5rLgogKgogKiBAcGFyYW0gU3BhbkNvbnRleHQgJGNvbnRleHQgVGhlIGxpbmtlZCBzcGFuIGNvbnRleHQKICogQHBhcmFtIGFycmF5PHN0cmluZywgYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58Ym9vbHxcRGF0ZVRpbWVJbnRlcmZhY2V8ZmxvYXR8aW50fHN0cmluZ3xcVGhyb3dhYmxlPnxBdHRyaWJ1dGVzICRhdHRyaWJ1dGVzIExpbmsgYXR0cmlidXRlcwogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":254,"slug":"span-limits","name":"span_limits","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributeCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"eventCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"linkCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributePerEventCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributePerLinkCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributeValueLengthLimit","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SpanLimits","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBTcGFuTGltaXRzIGNvbmZpZ3VyYXRpb24uCiAqCiAqIEBwYXJhbSBpbnQgJGF0dHJpYnV0ZUNvdW50TGltaXQgTWF4aW11bSBudW1iZXIgb2YgYXR0cmlidXRlcyBwZXIgc3BhbgogKiBAcGFyYW0gaW50ICRldmVudENvdW50TGltaXQgTWF4aW11bSBudW1iZXIgb2YgZXZlbnRzIHBlciBzcGFuCiAqIEBwYXJhbSBpbnQgJGxpbmtDb3VudExpbWl0IE1heGltdW0gbnVtYmVyIG9mIGxpbmtzIHBlciBzcGFuCiAqIEBwYXJhbSBpbnQgJGF0dHJpYnV0ZVBlckV2ZW50Q291bnRMaW1pdCBNYXhpbXVtIG51bWJlciBvZiBhdHRyaWJ1dGVzIHBlciBldmVudAogKiBAcGFyYW0gaW50ICRhdHRyaWJ1dGVQZXJMaW5rQ291bnRMaW1pdCBNYXhpbXVtIG51bWJlciBvZiBhdHRyaWJ1dGVzIHBlciBsaW5rCiAqIEBwYXJhbSBudWxsfGludCAkYXR0cmlidXRlVmFsdWVMZW5ndGhMaW1pdCBNYXhpbXVtIGxlbmd0aCBmb3Igc3RyaW5nIGF0dHJpYnV0ZSB2YWx1ZXMgKG51bGwgPSB1bmxpbWl0ZWQpCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":279,"slug":"log-record-limits","name":"log_record_limits","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributeCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributeValueLengthLimit","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"LogRecordLimits","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBMb2dSZWNvcmRMaW1pdHMgY29uZmlndXJhdGlvbi4KICoKICogQHBhcmFtIGludCAkYXR0cmlidXRlQ291bnRMaW1pdCBNYXhpbXVtIG51bWJlciBvZiBhdHRyaWJ1dGVzIHBlciBsb2cgcmVjb3JkCiAqIEBwYXJhbSBudWxsfGludCAkYXR0cmlidXRlVmFsdWVMZW5ndGhMaW1pdCBNYXhpbXVtIGxlbmd0aCBmb3Igc3RyaW5nIGF0dHJpYnV0ZSB2YWx1ZXMgKG51bGwgPSB1bmxpbWl0ZWQpCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":290,"slug":"metric-limits","name":"metric_limits","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"cardinalityLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2000"}],"return_type":[{"name":"MetricLimits","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBNZXRyaWNMaW1pdHMgY29uZmlndXJhdGlvbi4KICoKICogQHBhcmFtIGludCAkY2FyZGluYWxpdHlMaW1pdCBNYXhpbXVtIG51bWJlciBvZiB1bmlxdWUgYXR0cmlidXRlIGNvbWJpbmF0aW9ucyBwZXIgaW5zdHJ1bWVudAogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":301,"slug":"void-span-processor","name":"void_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidSpanProcessor","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRTcGFuUHJvY2Vzc29yLgogKgogKiBOby1vcCBzcGFuIHByb2Nlc3NvciB0aGF0IGRpc2NhcmRzIGFsbCBkYXRhLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":312,"slug":"void-metric-processor","name":"void_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidMetricProcessor","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRNZXRyaWNQcm9jZXNzb3IuCiAqCiAqIE5vLW9wIG1ldHJpYyBwcm9jZXNzb3IgdGhhdCBkaXNjYXJkcyBhbGwgZGF0YS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":323,"slug":"void-log-processor","name":"void_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidLogProcessor","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRMb2dQcm9jZXNzb3IuCiAqCiAqIE5vLW9wIGxvZyBwcm9jZXNzb3IgdGhhdCBkaXNjYXJkcyBhbGwgZGF0YS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":334,"slug":"void-exporter","name":"void_exporter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidExporter","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRFeHBvcnRlci4KICoKICogTm8tb3AgdW5pZmllZCBleHBvcnRlciB0aGF0IGRpc2NhcmRzIGxvZ3MsIG1ldHJpY3MsIGFuZCBzcGFucy4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":348,"slug":"memory-exporter","name":"memory_exporter","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"maxEntriesPerSignal","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MemoryExporter","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeUV4cG9ydGVyLgogKgogKiBVbmlmaWVkIGV4cG9ydGVyIHRoYXQgc3RvcmVzIGxvZ3MsIG1ldHJpY3MsIGFuZCBzcGFucyBpbiBtZW1vcnkgZm9yIGRpcmVjdCBhY2Nlc3MuCiAqIFVzZWZ1bCBmb3IgdGVzdGluZyBhbmQgaW5zcGVjdGlvbiB3aXRob3V0IHNlcmlhbGl6YXRpb24uCiAqCiAqIEBwYXJhbSBudWxsfGludCAkbWF4RW50cmllc1BlclNpZ25hbCBtYXhpbXVtIGVudHJpZXMgcmV0YWluZWQgcGVyIHNpZ25hbCB0eXBlOyBudWxsIGtlZXBzIGV2ZXJ5dGhpbmcKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":360,"slug":"memory-span-processor","name":"memory_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MemorySpanProcessor","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeVNwYW5Qcm9jZXNzb3IuCiAqCiAqIEBwYXJhbSBFeHBvcnRlciAkZXhwb3J0ZXIgVGhlIGV4cG9ydGVyIHRvIHNlbmQgc3BhbnMgdG8KICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBleHBvcnRlcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":374,"slug":"memory-metric-processor","name":"memory_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MemoryMetricProcessor","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeU1ldHJpY1Byb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBtZXRyaWNzIHRvCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":388,"slug":"memory-log-processor","name":"memory_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MemoryLogProcessor","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeUxvZ1Byb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBsb2dzIHRvCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":406,"slug":"tracer-provider","name":"tracer_provider","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"SpanProcessor","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sampler","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\ParentBasedSampler::..."},{"name":"limits","type":[{"name":"SpanLimits","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\SpanLimits::..."},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"TracerProvider","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlclByb3ZpZGVyLgogKgogKiBAcGFyYW0gU3BhblByb2Nlc3NvciAkcHJvY2Vzc29yIFRoZSBwcm9jZXNzb3IgZm9yIHNwYW5zCiAqIEBwYXJhbSBDbG9ja0ludGVyZmFjZSAkY2xvY2sgVGhlIGNsb2NrIGZvciB0aW1lc3RhbXBzCiAqIEBwYXJhbSBDb250ZXh0U3RvcmFnZSAkY29udGV4dFN0b3JhZ2UgU3RvcmFnZSBmb3IgY29udGV4dCBwcm9wYWdhdGlvbgogKiBAcGFyYW0gU2FtcGxlciAkc2FtcGxlciBTYW1wbGluZyBzdHJhdGVneSBmb3Igc3BhbnMKICogQHBhcmFtIFNwYW5MaW1pdHMgJGxpbWl0cyBMaW1pdHMgZm9yIHNwYW4gYXR0cmlidXRlcywgZXZlbnRzLCBhbmQgbGlua3MKICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIHJ1bnRpbWUgVGhyb3dhYmxlcyByYWlzZWQgYnkgdGhlIHByb2Nlc3NvcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":427,"slug":"logger-provider","name":"logger_provider","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"LogProcessor","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limits","type":[{"name":"LogRecordLimits","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Logger\\LogRecordLimits::..."},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"LoggerProvider","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExvZ2dlclByb3ZpZGVyLgogKgogKiBAcGFyYW0gTG9nUHJvY2Vzc29yICRwcm9jZXNzb3IgVGhlIHByb2Nlc3NvciBmb3IgbG9ncwogKiBAcGFyYW0gQ2xvY2tJbnRlcmZhY2UgJGNsb2NrIFRoZSBjbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gQ29udGV4dFN0b3JhZ2UgJGNvbnRleHRTdG9yYWdlIFN0b3JhZ2UgZm9yIHNwYW4gY29ycmVsYXRpb24KICogQHBhcmFtIExvZ1JlY29yZExpbWl0cyAkbGltaXRzIExpbWl0cyBmb3IgbG9nIHJlY29yZCBhdHRyaWJ1dGVzCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBydW50aW1lIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBwcm9jZXNzb3IKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":448,"slug":"meter-provider","name":"meter_provider","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"MetricProcessor","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"temporality","type":[{"name":"AggregationTemporality","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\AggregationTemporality::..."},{"name":"exemplarFilter","type":[{"name":"ExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\Exemplar\\TraceBasedExemplarFilter::..."},{"name":"limits","type":[{"name":"MetricLimits","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\MetricLimits::..."},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MeterProvider","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1ldGVyUHJvdmlkZXIuCiAqCiAqIEBwYXJhbSBNZXRyaWNQcm9jZXNzb3IgJHByb2Nlc3NvciBUaGUgcHJvY2Vzc29yIGZvciBtZXRyaWNzCiAqIEBwYXJhbSBDbG9ja0ludGVyZmFjZSAkY2xvY2sgVGhlIGNsb2NrIGZvciB0aW1lc3RhbXBzCiAqIEBwYXJhbSBBZ2dyZWdhdGlvblRlbXBvcmFsaXR5ICR0ZW1wb3JhbGl0eSBBZ2dyZWdhdGlvbiB0ZW1wb3JhbGl0eSBmb3IgbWV0cmljcwogKiBAcGFyYW0gRXhlbXBsYXJGaWx0ZXIgJGV4ZW1wbGFyRmlsdGVyIEZpbHRlciBmb3IgZXhlbXBsYXIgc2FtcGxpbmcgKGRlZmF1bHQ6IFRyYWNlQmFzZWRFeGVtcGxhckZpbHRlcikKICogQHBhcmFtIE1ldHJpY0xpbWl0cyAkbGltaXRzIENhcmRpbmFsaXR5IGxpbWl0cyBmb3IgbWV0cmljIGluc3RydW1lbnRzCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBydW50aW1lIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBwcm9jZXNzb3IKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":471,"slug":"telemetry","name":"telemetry","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"resource","type":[{"name":"Resource","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tracerProvider","type":[{"name":"TracerProvider","namespace":"Flow\\Telemetry\\Tracer","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"meterProvider","type":[{"name":"MeterProvider","namespace":"Flow\\Telemetry\\Meter","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"loggerProvider","type":[{"name":"LoggerProvider","namespace":"Flow\\Telemetry\\Logger","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBUZWxlbWV0cnkgaW5zdGFuY2Ugd2l0aCB0aGUgZ2l2ZW4gcHJvdmlkZXJzLgogKgogKiBJZiBwcm92aWRlcnMgYXJlIG5vdCBzcGVjaWZpZWQsIHZvaWQgcHJvdmlkZXJzIChuby1vcCkgYXJlIHVzZWQuCiAqCiAqIEBwYXJhbSBcRmxvd1xUZWxlbWV0cnlcUmVzb3VyY2UgJHJlc291cmNlIFRoZSByZXNvdXJjZSBkZXNjcmliaW5nIHRoZSBlbnRpdHkgcHJvZHVjaW5nIHRlbGVtZXRyeQogKiBAcGFyYW0gbnVsbHxUcmFjZXJQcm92aWRlciAkdHJhY2VyUHJvdmlkZXIgVGhlIHRyYWNlciBwcm92aWRlciAobnVsbCBmb3Igdm9pZC9kaXNhYmxlZCkKICogQHBhcmFtIG51bGx8TWV0ZXJQcm92aWRlciAkbWV0ZXJQcm92aWRlciBUaGUgbWV0ZXIgcHJvdmlkZXIgKG51bGwgZm9yIHZvaWQvZGlzYWJsZWQpCiAqIEBwYXJhbSBudWxsfExvZ2dlclByb3ZpZGVyICRsb2dnZXJQcm92aWRlciBUaGUgbG9nZ2VyIHByb3ZpZGVyIChudWxsIGZvciB2b2lkL2Rpc2FibGVkKQogKiBAcGFyYW0gRXJyb3JIYW5kbGVyICRlcnJvckhhbmRsZXIgSGFuZGxlciBwcm9wYWdhdGVkIHRvIGRlZmF1bHQgdm9pZCBwcm92aWRlcnMgd2hlbiBleHBsaWNpdCBvbmVzIGFyZSBub3Qgc3VwcGxpZWQKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":507,"slug":"instrumentation-scope","name":"instrumentation_scope","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"version","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'unknown'"},{"name":"schemaUrl","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Attributes::..."}],"return_type":[{"name":"InstrumentationScope","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJbnN0cnVtZW50YXRpb25TY29wZS4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBUaGUgaW5zdHJ1bWVudGF0aW9uIHNjb3BlIG5hbWUKICogQHBhcmFtIHN0cmluZyAkdmVyc2lvbiBUaGUgaW5zdHJ1bWVudGF0aW9uIHNjb3BlIHZlcnNpb24KICogQHBhcmFtIG51bGx8c3RyaW5nICRzY2hlbWFVcmwgT3B0aW9uYWwgc2NoZW1hIFVSTAogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":524,"slug":"batching-span-processor","name":"batching_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"batchSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"512"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"BatchingSpanProcessor","namespace":"Flow\\Telemetry\\Tracer\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhdGNoaW5nU3BhblByb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBzcGFucyB0bwogKiBAcGFyYW0gaW50ICRiYXRjaFNpemUgTnVtYmVyIG9mIHNwYW5zIHRvIGNvbGxlY3QgYmVmb3JlIGV4cG9ydGluZyAoZGVmYXVsdCA1MTIpCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":539,"slug":"pass-through-span-processor","name":"pass_through_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"PassThroughSpanProcessor","namespace":"Flow\\Telemetry\\Tracer\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhc3NUaHJvdWdoU3BhblByb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBzcGFucyB0bwogKiBAcGFyYW0gRXJyb3JIYW5kbGVyICRlcnJvckhhbmRsZXIgSGFuZGxlciBmb3IgVGhyb3dhYmxlcyByYWlzZWQgYnkgdGhlIGV4cG9ydGVyCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":554,"slug":"batching-metric-processor","name":"batching_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"batchSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"512"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"BatchingMetricProcessor","namespace":"Flow\\Telemetry\\Meter\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhdGNoaW5nTWV0cmljUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIG1ldHJpY3MgdG8KICogQHBhcmFtIGludCAkYmF0Y2hTaXplIE51bWJlciBvZiBtZXRyaWNzIHRvIGNvbGxlY3QgYmVmb3JlIGV4cG9ydGluZyAoZGVmYXVsdCA1MTIpCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":569,"slug":"pass-through-metric-processor","name":"pass_through_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"PassThroughMetricProcessor","namespace":"Flow\\Telemetry\\Meter\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhc3NUaHJvdWdoTWV0cmljUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIG1ldHJpY3MgdG8KICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBleHBvcnRlcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":584,"slug":"batching-log-processor","name":"batching_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"batchSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"512"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"BatchingLogProcessor","namespace":"Flow\\Telemetry\\Logger\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhdGNoaW5nTG9nUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIGxvZ3MgdG8KICogQHBhcmFtIGludCAkYmF0Y2hTaXplIE51bWJlciBvZiBsb2dzIHRvIGNvbGxlY3QgYmVmb3JlIGV4cG9ydGluZyAoZGVmYXVsdCA1MTIpCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":599,"slug":"pass-through-log-processor","name":"pass_through_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"PassThroughLogProcessor","namespace":"Flow\\Telemetry\\Logger\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhc3NUaHJvdWdoTG9nUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIGxvZ3MgdG8KICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBleHBvcnRlcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":614,"slug":"pipeline-log-processor","name":"pipeline_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"middleware","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sink","type":[{"name":"LogSink","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PipelineLogProcessor","namespace":"Flow\\Telemetry\\Logger\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBpcGVsaW5lTG9nUHJvY2Vzc29yOiBydW4gZWFjaCBsb2cgZW50cnkgdGhyb3VnaCBhbiBvcmRlcmVkIGNoYWluIG9mCiAqIG1pZGRsZXdhcmUsIHRoZW4gZm9yd2FyZCB0aGUgc3Vydml2b3JzIHRvIGEgc2luZ2xlIHNpbmsuCiAqCiAqIEBwYXJhbSBsaXN0PExvZ01pZGRsZXdhcmU+ICRtaWRkbGV3YXJlIHJ1biBpbiBvcmRlcjsgdGhlIGZpcnN0IHRvIGRyb3AgYW4gZW50cnkgc2hvcnQtY2lyY3VpdHMgdGhlIHJlc3QKICogQHBhcmFtIExvZ1NpbmsgJHNpbmsgdGhlIHRlcm1pbmFsIHByb2Nlc3NvciB0aGF0IGV4cG9ydHMgc3Vydml2aW5nIGVudHJpZXMKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":626,"slug":"enriching-log-middleware","name":"enriching_log_middleware","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnrichingLogMiddleware","namespace":"Flow\\Telemetry\\Logger\\Middleware","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFbnJpY2hpbmdMb2dNaWRkbGV3YXJlIHRoYXQgbWVyZ2VzIGRlZmF1bHQgYXR0cmlidXRlcyBpbnRvIGV2ZXJ5IGxvZwogKiBlbnRyeS4gQXR0cmlidXRlcyBzZXQgYXQgdGhlIGNhbGwgc2l0ZSB3aW4gb3ZlciB0aGVzZSBkZWZhdWx0cy4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58Ym9vbHxcRGF0ZVRpbWVJbnRlcmZhY2V8ZmxvYXR8aW50fHN0cmluZ3xcVGhyb3dhYmxlPnxBdHRyaWJ1dGVzICRhdHRyaWJ1dGVzCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":637,"slug":"attribute-filtering-log-middleware","name":"attribute_filtering_log_middleware","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AttributeFilteringLogMiddleware","namespace":"Flow\\Telemetry\\Logger\\Middleware","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXJpbmdMb2dNaWRkbGV3YXJlIHRoYXQgZHJvcHMgbG9nIGVudHJpZXMgbWF0Y2hpbmcgdGhlIGZpbHRlci4KICoKICogQHBhcmFtIEF0dHJpYnV0ZUZpbHRlciAkZmlsdGVyIFRoZSBhdHRyaWJ1dGUgZmlsdGVyIHRvIGFwcGx5CiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":648,"slug":"severity-filtering-log-middleware","name":"severity_filtering_log_middleware","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"minimumSeverity","type":[{"name":"Severity","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Logger\\Severity::..."}],"return_type":[{"name":"SeverityFilteringLogMiddleware","namespace":"Flow\\Telemetry\\Logger\\Middleware","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNldmVyaXR5RmlsdGVyaW5nTG9nTWlkZGxld2FyZSB0aGF0IGRyb3BzIGxvZyBlbnRyaWVzIGJlbG93IGEgbWluaW11bSBzZXZlcml0eS4KICoKICogQHBhcmFtIFNldmVyaXR5ICRtaW5pbXVtU2V2ZXJpdHkgTWluaW11bSBzZXZlcml0eSBsZXZlbCAoZGVmYXVsdDogSU5GTykKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":662,"slug":"attribute-rule","name":"attribute_rule","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"path","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"mode","type":[{"name":"MatchMode","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"expected","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"caseSensitive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"AttributeRule","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNpbmdsZSBhdHRyaWJ1dGUtbWF0Y2hpbmcgcnVsZSBmb3IgYW4gQXR0cmlidXRlRmlsdGVyLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nPnxzdHJpbmcgJHBhdGggYXR0cmlidXRlIHBhdGg6IGEgdG9wLWxldmVsIGtleSwgb3Igc2VnbWVudHMgZGVzY2VuZGluZyBpbnRvIG5lc3RlZCBhcnJheSB2YWx1ZXMKICogQHBhcmFtIE1hdGNoTW9kZSAkbW9kZSBjb21wYXJpc29uIGFwcGxpZWQgYmV0d2VlbiB0aGUgdmFsdWUgYXQgdGhlIHBhdGggYW5kIHRoZSBleHBlY3RlZCB2YWx1ZQogKiBAcGFyYW0gYm9vbHxEYXRlVGltZUludGVyZmFjZXxmbG9hdHxpbnR8c3RyaW5nICRleHBlY3RlZCBleHBlY3RlZCB2YWx1ZSAobXVzdCBiZSBhIHN0cmluZyBmb3IgdGhlIHBhdHRlcm4gbW9kZXMpCiAqIEBwYXJhbSBib29sICRjYXNlU2Vuc2l0aXZlIGFwcGxpZXMgdG8gdGhlIHN1YnN0cmluZyBtb2RlcyBvbmx5IChTVEFSVFNfV0lUSCwgRU5EU19XSVRILCBDT05UQUlOUykKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":675,"slug":"all","name":"all","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matchers","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgbWF0Y2hlcnMgc28gdGhhdCBldmVyeSBvbmUgbXVzdCBtYXRjaCAobG9naWNhbCBBTkQpLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":684,"slug":"any","name":"any","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matchers","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgbWF0Y2hlcnMgc28gdGhhdCBhdCBsZWFzdCBvbmUgbXVzdCBtYXRjaCAobG9naWNhbCBPUikuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":693,"slug":"not","name":"not","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matcher","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Not","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5lZ2F0ZSBhIG1hdGNoZXIgKGxvZ2ljYWwgTk9UKS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":712,"slug":"attribute-filter","name":"attribute_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matcher","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"exclude","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"sources","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[...]"},{"name":"cacheDir","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"cacheDirPermissions","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"448"}],"return_type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXIgZnJvbSBhIG1hdGNoZXIuCiAqCiAqIEBwYXJhbSBNYXRjaGVyICRtYXRjaGVyIHRoZSBtYXRjaGVyIHRvIGV2YWx1YXRlIGFnYWluc3QgYSBzaWduYWwncyBhdHRyaWJ1dGVzIChjb21wb3NlIHdpdGggYWxsKCksIGFueSgpLCBub3QoKSkKICogQHBhcmFtIGJvb2wgJGV4Y2x1ZGUgd2hlbiB0cnVlIChkZWZhdWx0KSBhIG1hdGNoIGRyb3BzIHRoZSBzaWduYWw7IHdoZW4gZmFsc2Ugb25seSBtYXRjaGluZyBzaWduYWxzIGFyZSBrZXB0CiAqIEBwYXJhbSBsaXN0PEF0dHJpYnV0ZVNvdXJjZT4gJHNvdXJjZXMgd2hpY2ggYXR0cmlidXRlIHNldHMgdG8gaW5zcGVjdCAoc2lnbmFsLCByZXNvdXJjZSBhbmQvb3Igc2NvcGUpOyB0aGUgbWF0Y2hlciBpcwogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE9SLWNvbWJpbmVkIGFjcm9zcyB0aGVtLCBkZWZhdWx0aW5nIHRvIHRoZSBzaWduYWwncyBvd24gYXR0cmlidXRlcwogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGNhY2hlRGlyIGRpcmVjdG9yeSBmb3IgdGhlIGdlbmVyYXRlZCBtYXRjaGVyIGZpbGUgKGRlZmF1bHRzIHRvIHRoZSBzeXN0ZW0gdGVtcCBkaXJlY3RvcnkpLiBJdCBpcwogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGByZXF1aXJlYGQsIHNvIGl0IE1VU1QgYmUgdHJ1c3RlZCAtIG5vdCB3cml0YWJsZSBieSB1bnRydXN0ZWQgdXNlcnMuIFByZWZlciBhbgogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFwcGxpY2F0aW9uLXByaXZhdGUgZGlyZWN0b3J5IG92ZXIgdGhlIHNoYXJlZCBzeXN0ZW0gdGVtcCBpbiBtdWx0aS10ZW5hbnQgZW52aXJvbm1lbnRzLgogKiBAcGFyYW0gaW50ICRjYWNoZURpclBlcm1pc3Npb25zIG1vZGUgYXBwbGllZCB3aGVuIHRoZSBjYWNoZSBkaXJlY3RvcnkgaXMgY3JlYXRlZCAob2N0YWwsIHN1YmplY3QgdG8gdW1hc2s7IGRlZmF1bHRzCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdG8gMDcwMCAtIG93bmVyIG9ubHksIHNpbmNlIHRoZSBkaXJlY3RvcnkgaG9sZHMgYHJlcXVpcmVgZCBQSFApCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":729,"slug":"attribute-filtering-metric-processor","name":"attribute_filtering_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"MetricProcessor","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AttributeFilteringMetricProcessor","namespace":"Flow\\Telemetry\\Meter\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXJpbmdNZXRyaWNQcm9jZXNzb3IuCiAqCiAqIEBwYXJhbSBNZXRyaWNQcm9jZXNzb3IgJHByb2Nlc3NvciBUaGUgcHJvY2Vzc29yIHRvIHdyYXAKICogQHBhcmFtIEF0dHJpYnV0ZUZpbHRlciAkZmlsdGVyIFRoZSBhdHRyaWJ1dGUgZmlsdGVyIHRvIGFwcGx5CiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":743,"slug":"attribute-filtering-span-processor","name":"attribute_filtering_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"SpanProcessor","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AttributeFilteringSpanProcessor","namespace":"Flow\\Telemetry\\Tracer\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXJpbmdTcGFuUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gU3BhblByb2Nlc3NvciAkcHJvY2Vzc29yIFRoZSBwcm9jZXNzb3IgdG8gd3JhcAogKiBAcGFyYW0gQXR0cmlidXRlRmlsdGVyICRmaWx0ZXIgVGhlIGF0dHJpYnV0ZSBmaWx0ZXIgdG8gYXBwbHkKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":762,"slug":"console-exporter","name":"console_exporter","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"colors","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"maxLogBodyLength","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"100"},{"name":"logOptions","type":[{"name":"ConsoleLogOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Provider\\Console\\ConsoleLogOptions::..."},{"name":"metricOptions","type":[{"name":"ConsoleMetricOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Provider\\Console\\ConsoleMetricOptions::..."},{"name":"spanOptions","type":[{"name":"ConsoleSpanOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Provider\\Console\\ConsoleSpanOptions::..."}],"return_type":[{"name":"ConsoleExporter","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHVuaWZpZWQgQ29uc29sZUV4cG9ydGVyIGZvciBsb2dzLCBtZXRyaWNzLCBhbmQgc3BhbnMuCiAqCiAqIE91dHB1dHMgdGVsZW1ldHJ5IHRvIHRoZSBjb25zb2xlIHdpdGggQVNDSUkgdGFibGUgZm9ybWF0dGluZyBhbmQgb3B0aW9uYWwgQU5TSSBjb2xvcnMuCiAqCiAqIEBwYXJhbSBib29sICRjb2xvcnMgV2hldGhlciB0byB1c2UgQU5TSSBjb2xvcnMgKGRlZmF1bHQ6IHRydWUpCiAqIEBwYXJhbSBudWxsfGludCAkbWF4TG9nQm9keUxlbmd0aCBNYXhpbXVtIGxlbmd0aCBmb3IgbG9nIGJvZHkrYXR0cmlidXRlcyBjb2x1bW4gKG51bGwgPSBubyBsaW1pdCkKICogQHBhcmFtIENvbnNvbGVMb2dPcHRpb25zICRsb2dPcHRpb25zIERpc3BsYXkgb3B0aW9ucyBmb3IgbG9nIHJlY29yZHMKICogQHBhcmFtIENvbnNvbGVNZXRyaWNPcHRpb25zICRtZXRyaWNPcHRpb25zIERpc3BsYXkgb3B0aW9ucyBmb3IgbWV0cmljcwogKiBAcGFyYW0gQ29uc29sZVNwYW5PcHRpb25zICRzcGFuT3B0aW9ucyBEaXNwbGF5IG9wdGlvbnMgZm9yIHNwYW5zCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":776,"slug":"console-span-options","name":"console_span_options","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleSpanOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlU3Bhbk9wdGlvbnMgd2l0aCBhbGwgZGlzcGxheSBvcHRpb25zIGVuYWJsZWQgKGRlZmF1bHQgYmVoYXZpb3IpLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":785,"slug":"console-span-options-minimal","name":"console_span_options_minimal","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleSpanOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlU3Bhbk9wdGlvbnMgd2l0aCBtaW5pbWFsIGRpc3BsYXkgKGxlZ2FjeSBjb21wYWN0IGZvcm1hdCkuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":794,"slug":"console-log-options","name":"console_log_options","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleLogOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTG9nT3B0aW9ucyB3aXRoIGFsbCBkaXNwbGF5IG9wdGlvbnMgZW5hYmxlZCAoZGVmYXVsdCBiZWhhdmlvcikuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":803,"slug":"console-log-options-minimal","name":"console_log_options_minimal","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleLogOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTG9nT3B0aW9ucyB3aXRoIG1pbmltYWwgZGlzcGxheSAobGVnYWN5IGNvbXBhY3QgZm9ybWF0KS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":812,"slug":"console-metric-options","name":"console_metric_options","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleMetricOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTWV0cmljT3B0aW9ucyB3aXRoIGFsbCBkaXNwbGF5IG9wdGlvbnMgZW5hYmxlZCAoZGVmYXVsdCBiZWhhdmlvcikuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":821,"slug":"console-metric-options-minimal","name":"console_metric_options_minimal","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleMetricOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTWV0cmljT3B0aW9ucyB3aXRoIG1pbmltYWwgZGlzcGxheSAobGVnYWN5IGNvbXBhY3QgZm9ybWF0KS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":830,"slug":"always-on-exemplar-filter","name":"always_on_exemplar_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOnExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPbkV4ZW1wbGFyRmlsdGVyLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":839,"slug":"always-off-exemplar-filter","name":"always_off_exemplar_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOffExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPZmZFeGVtcGxhckZpbHRlci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":848,"slug":"trace-based-exemplar-filter","name":"trace_based_exemplar_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"TraceBasedExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlQmFzZWRFeGVtcGxhckZpbHRlci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":857,"slug":"always-on-sampler","name":"always_on_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOnSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPblNhbXBsZXIuIFJlY29yZHMgYW5kIHNhbXBsZXMgZXZlcnkgc3Bhbi4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":866,"slug":"always-off-sampler","name":"always_off_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOffSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPZmZTYW1wbGVyLiBEcm9wcyBldmVyeSBzcGFuLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":877,"slug":"trace-id-ratio-based-sampler","name":"trace_id_ratio_based_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"ratio","type":[{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TraceIdRatioBasedSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlSWRSYXRpb0Jhc2VkU2FtcGxlci4gU2FtcGxlcyBhIGRldGVybWluaXN0aWMgZnJhY3Rpb24gb2YgdHJhY2VzLgogKgogKiBAcGFyYW0gZmxvYXQgJHJhdGlvIFNhbXBsaW5nIHByb2JhYmlsaXR5IGJldHdlZW4gMC4wIGFuZCAxLjAKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":889,"slug":"parent-based-sampler","name":"parent_based_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"root","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\AlwaysOnSampler::..."}],"return_type":[{"name":"ParentBasedSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhcmVudEJhc2VkU2FtcGxlci4gSG9ub3JzIHRoZSBwYXJlbnQgc3BhbidzIHNhbXBsaW5nIGRlY2lzaW9uLCBmYWxsaW5nCiAqIGJhY2sgdG8gdGhlIHJvb3Qgc2FtcGxlciBmb3Igc3BhbnMgd2l0aG91dCBhIHBhcmVudC4KICoKICogQHBhcmFtIFNhbXBsZXIgJHJvb3QgU2FtcGxlciB1c2VkIGZvciByb290IHNwYW5zIChubyBwYXJlbnQpCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":905,"slug":"attribute-matching-sampler","name":"attribute_matching_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"delegate","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\AlwaysOnSampler::..."}],"return_type":[{"name":"AttributeMatchingSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVNYXRjaGluZ1NhbXBsZXIuIERyb3BzIHNwYW5zIHdob3NlIHN0YXJ0LXRpbWUgYXR0cmlidXRlcyBtYXRjaAogKiB0aGUgZmlsdGVyIChvciBrZWVwcyBPTkxZIG1hdGNoaW5nIHNwYW5zIHdoZW4gdGhlIGZpbHRlcidzIGV4Y2x1ZGUgaXMgZmFsc2UpLCBhbmQKICogZGVmZXJzIGFsbCBvdGhlciBzcGFucyB0byB0aGUgZGVsZWdhdGUgc2FtcGxlci4KICoKICogT25seSBhdHRyaWJ1dGVzIGF2YWlsYWJsZSBhdCBzcGFuIHN0YXJ0IGFyZSB2aXNpYmxlOyBhdHRyaWJ1dGVzIGFkZGVkIGxhdGVyIGFyZSBub3QuCiAqCiAqIEBwYXJhbSBBdHRyaWJ1dGVGaWx0ZXIgJGZpbHRlciBUaGUgYXR0cmlidXRlIGZpbHRlciBldmFsdWF0ZWQgYWdhaW5zdCB0aGUgc3BhbidzIHN0YXJ0IGF0dHJpYnV0ZXMKICogQHBhcmFtIFNhbXBsZXIgJGRlbGVnYXRlIFNhbXBsZXIgdGhhdCBkZWNpZGVzIHNwYW5zIHdoaWNoIGRvIG5vdCBtYXRjaCAoZGVmYXVsdDogQWx3YXlzT25TYW1wbGVyKQogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":919,"slug":"propagation-context","name":"propagation_context","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"spanContext","type":[{"name":"SpanContext","namespace":"Flow\\Telemetry\\Tracer","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"baggage","type":[{"name":"Baggage","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PropagationContext","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFByb3BhZ2F0aW9uQ29udGV4dC4KICoKICogQHBhcmFtIG51bGx8U3BhbkNvbnRleHQgJHNwYW5Db250ZXh0IE9wdGlvbmFsIHNwYW4gY29udGV4dAogKiBAcGFyYW0gbnVsbHxCYWdnYWdlICRiYWdnYWdlIE9wdGlvbmFsIGJhZ2dhZ2UKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":930,"slug":"array-carrier","name":"array_carrier","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ArrayCarrier","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBcnJheUNhcnJpZXIuCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIHN0cmluZz4gJGRhdGEgSW5pdGlhbCBjYXJyaWVyIGRhdGEKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":939,"slug":"superglobal-carrier","name":"superglobal_carrier","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"SuperglobalCarrier","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFN1cGVyZ2xvYmFsQ2Fycmllci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":948,"slug":"w3c-trace-context","name":"w3c_trace_context","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"W3CTraceContext","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFczQ1RyYWNlQ29udGV4dCBwcm9wYWdhdG9yLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":957,"slug":"w3c-baggage","name":"w3c_baggage","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"W3CBaggage","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFczQ0JhZ2dhZ2UgcHJvcGFnYXRvci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":968,"slug":"composite-propagator","name":"composite_propagator","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"propagators","type":[{"name":"Propagator","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"CompositePropagator","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENvbXBvc2l0ZVByb3BhZ2F0b3IuCiAqCiAqIEBwYXJhbSBQcm9wYWdhdG9yIC4uLiRwcm9wYWdhdG9ycyBUaGUgcHJvcGFnYXRvcnMgdG8gY29tYmluZQogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":979,"slug":"chain-detector","name":"chain_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"detectors","type":[{"name":"ResourceDetector","namespace":"Flow\\Telemetry\\Resource","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ChainDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENoYWluRGV0ZWN0b3IuCiAqCiAqIEBwYXJhbSBSZXNvdXJjZURldGVjdG9yIC4uLiRkZXRlY3RvcnMgVGhlIGRldGVjdG9ycyB0byBjaGFpbgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":988,"slug":"os-detector","name":"os_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"OsDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPc0RldGVjdG9yLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":997,"slug":"host-detector","name":"host_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"HostDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEhvc3REZXRlY3Rvci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1006,"slug":"process-detector","name":"process_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ProcessDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFByb2Nlc3NEZXRlY3Rvci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1015,"slug":"environment-detector","name":"environment_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"EnvironmentDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFbnZpcm9ubWVudERldGVjdG9yLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1024,"slug":"composer-detector","name":"composer_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ComposerDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENvbXBvc2VyRGV0ZWN0b3IuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1036,"slug":"git-detector","name":"git_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"workingDirectory","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"gitBinary","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'git'"}],"return_type":[{"name":"GitDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdpdERldGVjdG9yLgogKgogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHdvcmtpbmdEaXJlY3RvcnkgRGlyZWN0b3J5IHRvIHJ1biBnaXQgaW4gKGRlZmF1bHQ6IGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkpCiAqIEBwYXJhbSBzdHJpbmcgJGdpdEJpbmFyeSBQYXRoIHRvIHRoZSBnaXQgYmluYXJ5IChkZWZhdWx0OiAiZ2l0IiwgcmVzb2x2ZWQgZnJvbSAkUEFUSCkKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1047,"slug":"manual-detector","name":"manual_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ManualDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1hbnVhbERldGVjdG9yLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBhcnJheTxhcnJheS1rZXksIG1peGVkPnxib29sfFxEYXRlVGltZUludGVyZmFjZXxmbG9hdHxpbnR8c3RyaW5nfFxUaHJvd2FibGU+ICRhdHRyaWJ1dGVzIFJlc291cmNlIGF0dHJpYnV0ZXMKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1059,"slug":"caching-detector","name":"caching_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"detector","type":[{"name":"ResourceDetector","namespace":"Flow\\Telemetry\\Resource","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"cachePath","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CachingDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENhY2hpbmdEZXRlY3Rvci4KICoKICogQHBhcmFtIFJlc291cmNlRGV0ZWN0b3IgJGRldGVjdG9yIFRoZSBkZXRlY3RvciB0byB3cmFwCiAqIEBwYXJhbSBudWxsfHN0cmluZyAkY2FjaGVQYXRoIENhY2hlIGZpbGUgcGF0aCAoZGVmYXVsdDogc3lzX2dldF90ZW1wX2RpcigpL2Zsb3dfdGVsZW1ldHJ5X3Jlc291cmNlLmNhY2hlKQogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1070,"slug":"resource-detector","name":"resource_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"detectors","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ChainDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJlc291cmNlIGRldGVjdG9yIGNoYWluLgogKgogKiBAcGFyYW0gYXJyYXk8UmVzb3VyY2VEZXRlY3Rvcj4gJGRldGVjdG9ycyBPcHRpb25hbCBjdXN0b20gZGV0ZWN0b3JzIChlbXB0eSA9IHVzZSBkZWZhdWx0cykKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1089,"slug":"error-log-handler","name":"error_log_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"messageType","type":[{"name":"ErrorLogMessageType","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogMessageType::..."},{"name":"expandNewlines","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"messagePrefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'[flow-telemetry]'"}],"return_type":[{"name":"ErrorLogHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB0aGUgZGVmYXVsdCBFcnJvckxvZ0hhbmRsZXIuIFdyaXRlcyB2aWEgUEhQJ3MgZXJyb3JfbG9nKCkuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1102,"slug":"stream-error-handler","name":"stream_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"destination","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filePermissions","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"420"},{"name":"createDirectories","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"messagePrefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'[flow-telemetry]'"}],"return_type":[{"name":"StreamHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFN0cmVhbUhhbmRsZXIuIEFwcGVuZHMgZm9ybWF0dGVkIFRocm93YWJsZXMgKG9uZSBwZXIgbGluZSkgdG8gYSBmaWxlCiAqIHBhdGggb3IgcGhwOi8vIHN0cmVhbSB3cmFwcGVyLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1115,"slug":"syslog-error-handler","name":"syslog_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"ident","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'flow-telemetry'"},{"name":"facility","type":[{"name":"SyslogFacility","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogFacility::..."},{"name":"logOpts","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"severity","type":[{"name":"SyslogSeverity","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogSeverity::..."}],"return_type":[{"name":"SyslogHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFN5c2xvZ0hhbmRsZXIuIFdyaXRlcyB2aWEgb3BlbmxvZy9zeXNsb2cvY2xvc2Vsb2cuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1128,"slug":"udp-syslog-error-handler","name":"udp_syslog_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"port","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"514"},{"name":"ident","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'flow-telemetry'"},{"name":"facility","type":[{"name":"SyslogFacility","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogFacility::..."},{"name":"severity","type":[{"name":"SyslogSeverity","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogSeverity::..."}],"return_type":[{"name":"UdpSyslogHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFVkcFN5c2xvZ0hhbmRsZXIuIFNlbmRzIFJGQyA1NDI0LXN0eWxlIHN5c2xvZyBmcmFtZXMgb3ZlciBVRFAuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1142,"slug":"composite-error-handler","name":"composite_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"handlers","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"CompositeErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEZhbiBlcnJvcnMgb3V0IHRvIG11bHRpcGxlIGhhbmRsZXJzLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1151,"slug":"null-error-handler","name":"null_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"NullErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERpc2NhcmQgZXZlcnkgZXJyb3IuIFVzZSBvbmx5IGluIHRlc3RzIG9yIGZvciBleHBsaWNpdCBzaWxlbmNlLgogKi8="},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":29,"slug":"azurite-url-factory","name":"azurite_url_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'localhost'"},{"name":"port","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'10000'"},{"name":"secure","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AzuriteURLFactory","namespace":"Flow\\Azure\\SDK\\BlobService\\URLFactory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":38,"slug":"azure-shared-key-authorization-factory","name":"azure_shared_key_authorization_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"account","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SharedKeyFactory","namespace":"Flow\\Azure\\SDK\\AuthorizationFactory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":48,"slug":"azure-blob-service-config","name":"azure_blob_service_config","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"account","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"container","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Configuration","namespace":"Flow\\Azure\\SDK\\BlobService","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":54,"slug":"azure-url-factory","name":"azure_url_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'blob.core.windows.net'"}],"return_type":[{"name":"AzureURLFactory","namespace":"Flow\\Azure\\SDK\\BlobService\\URLFactory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":60,"slug":"azure-http-factory","name":"azure_http_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"request_factory","type":[{"name":"RequestFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stream_factory","type":[{"name":"StreamFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"HttpFactory","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":68,"slug":"azure-blob-service","name":"azure_blob_service","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"configuration","type":[{"name":"Configuration","namespace":"Flow\\Azure\\SDK\\BlobService","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"azure_authorization_factory","type":[{"name":"AuthorizationFactory","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"azure_http_factory","type":[{"name":"HttpFactory","namespace":"Flow\\Azure\\SDK","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"azure_url_factory","type":[{"name":"URLFactory","namespace":"Flow\\Azure\\SDK","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"logger","type":[{"name":"LoggerInterface","namespace":"Psr\\Log","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"BlobServiceInterface","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/azure\/src\/Flow\/Filesystem\/Bridge\/Azure\/DSL\/functions.php","start_line_in_file":16,"slug":"azure-filesystem-options","name":"azure_filesystem_options","namespace":"Flow\\Filesystem\\Bridge\\Azure\\DSL","parameters":[],"return_type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\Azure","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/azure\/src\/Flow\/Filesystem\/Bridge\/Azure\/DSL\/functions.php","start_line_in_file":22,"slug":"azure-filesystem","name":"azure_filesystem","namespace":"Flow\\Filesystem\\Bridge\\Azure\\DSL","parameters":[{"name":"blob_service","type":[{"name":"BlobServiceInterface","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\Azure","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Bridge\\Azure\\Options::..."},{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'azure-blob'"}],"return_type":[{"name":"AzureBlobFilesystem","namespace":"Flow\\Filesystem\\Bridge\\Azure","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/async-aws\/src\/Flow\/Filesystem\/Bridge\/AsyncAWS\/DSL\/functions.php","start_line_in_file":20,"slug":"aws-s3-client","name":"aws_s3_client","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS\\DSL","parameters":[{"name":"configuration","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"S3Client","namespace":"AsyncAws\\S3","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"S3_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxDb25maWd1cmF0aW9uOjpPUFRJT05fKiwgbnVsbHxzdHJpbmc+ICRjb25maWd1cmF0aW9uIC0gZm9yIGRldGFpbHMgcGxlYXNlIHNlZSBodHRwczovL2FzeW5jLWF3cy5jb20vY2xpZW50cy9zMy5odG1sCiAqLw=="},{"repository_path":"src\/bridge\/filesystem\/async-aws\/src\/Flow\/Filesystem\/Bridge\/AsyncAWS\/DSL\/functions.php","start_line_in_file":26,"slug":"aws-s3-filesystem","name":"aws_s3_filesystem","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS\\DSL","parameters":[{"name":"bucket","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"s3Client","type":[{"name":"S3Client","namespace":"AsyncAws\\S3","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Bridge\\AsyncAWS\\Options::..."},{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'aws-s3'"}],"return_type":[{"name":"AsyncAWSS3Filesystem","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"S3_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/sftp\/src\/Flow\/Filesystem\/Bridge\/SFTP\/DSL\/functions.php","start_line_in_file":24,"slug":"sftp-client","name":"sftp_client","namespace":"Flow\\Filesystem\\Bridge\\SFTP\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"user","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"credential","type":[{"name":"PrivateKey","namespace":"phpseclib4\\Crypt\\Common","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"port","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"22"}],"return_type":[{"name":"SFTP","namespace":"phpseclib4\\Net","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SFTP_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0aHJvd3MgUnVudGltZUV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/bridge\/filesystem\/sftp\/src\/Flow\/Filesystem\/Bridge\/SFTP\/DSL\/functions.php","start_line_in_file":46,"slug":"sftp-filesystem","name":"sftp_filesystem","namespace":"Flow\\Filesystem\\Bridge\\SFTP\\DSL","parameters":[{"name":"sftp","type":[{"name":"SFTP","namespace":"phpseclib4\\Net","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\SFTP","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Bridge\\SFTP\\Options::..."},{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'sftp'"}],"return_type":[{"name":"SFTPFilesystem","namespace":"Flow\\Filesystem\\Bridge\\SFTP","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SFTP_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/sftp\/src\/Flow\/Filesystem\/Bridge\/SFTP\/DSL\/functions.php","start_line_in_file":52,"slug":"sftp-filesystem-options","name":"sftp_filesystem_options","namespace":"Flow\\Filesystem\\Bridge\\SFTP\\DSL","parameters":[],"return_type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\SFTP","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SFTP_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":40,"slug":"value-normalizer","name":"value_normalizer","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ValueNormalizer","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZhbHVlTm9ybWFsaXplciBmb3IgY29udmVydGluZyBhcmJpdHJhcnkgUEhQIHZhbHVlcyB0byBUZWxlbWV0cnkgYXR0cmlidXRlIHR5cGVzLgogKgogKiBUaGUgbm9ybWFsaXplciBoYW5kbGVzOgogKiAtIG51bGwg4oaSICdudWxsJyBzdHJpbmcKICogLSBzY2FsYXJzIChzdHJpbmcsIGludCwgZmxvYXQsIGJvb2wpIOKGkiB1bmNoYW5nZWQKICogLSBEYXRlVGltZUludGVyZmFjZSDihpIgdW5jaGFuZ2VkCiAqIC0gVGhyb3dhYmxlIOKGkiB1bmNoYW5nZWQKICogLSBhcnJheXMg4oaSIHJlY3Vyc2l2ZWx5IG5vcm1hbGl6ZWQKICogLSBvYmplY3RzIHdpdGggX190b1N0cmluZygpIOKGkiBzdHJpbmcgY2FzdAogKiAtIG9iamVjdHMgd2l0aG91dCBfX3RvU3RyaW5nKCkg4oaSIGNsYXNzIG5hbWUKICogLSBvdGhlciB0eXBlcyDihpIgZ2V0X2RlYnVnX3R5cGUoKSByZXN1bHQKICoKICogRXhhbXBsZSB1c2FnZToKICogYGBgcGhwCiAqICRub3JtYWxpemVyID0gdmFsdWVfbm9ybWFsaXplcigpOwogKiAkbm9ybWFsaXplZCA9ICRub3JtYWxpemVyLT5ub3JtYWxpemUoJHZhbHVlKTsKICogYGBgCiAqLw=="},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":73,"slug":"severity-mapper","name":"severity_mapper","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[{"name":"customMapping","type":[{"name":"array","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SeverityMapper","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNldmVyaXR5TWFwcGVyIGZvciBtYXBwaW5nIE1vbm9sb2cgbGV2ZWxzIHRvIFRlbGVtZXRyeSBzZXZlcml0aWVzLgogKgogKiBAcGFyYW0gbnVsbHxhcnJheTxpbnQsIFNldmVyaXR5PiAkY3VzdG9tTWFwcGluZyBPcHRpb25hbCBjdXN0b20gbWFwcGluZyAoTW9ub2xvZyBMZXZlbCB2YWx1ZSA9PiBUZWxlbWV0cnkgU2V2ZXJpdHkpCiAqCiAqIEV4YW1wbGUgd2l0aCBkZWZhdWx0IG1hcHBpbmc6CiAqIGBgYHBocAogKiAkbWFwcGVyID0gc2V2ZXJpdHlfbWFwcGVyKCk7CiAqIGBgYAogKgogKiBFeGFtcGxlIHdpdGggY3VzdG9tIG1hcHBpbmc6CiAqIGBgYHBocAogKiB1c2UgTW9ub2xvZ1xMZXZlbDsKICogdXNlIEZsb3dcVGVsZW1ldHJ5XExvZ2dlclxTZXZlcml0eTsKICoKICogJG1hcHBlciA9IHNldmVyaXR5X21hcHBlcihbCiAqICAgICBMZXZlbDo6RGVidWctPnZhbHVlID0+IFNldmVyaXR5OjpERUJVRywKICogICAgIExldmVsOjpJbmZvLT52YWx1ZSA9PiBTZXZlcml0eTo6SU5GTywKICogICAgIExldmVsOjpOb3RpY2UtPnZhbHVlID0+IFNldmVyaXR5OjpXQVJOLCAgLy8gQ3VzdG9tOiBOT1RJQ0Ug4oaSIFdBUk4gaW5zdGVhZCBvZiBJTkZPCiAqICAgICBMZXZlbDo6V2FybmluZy0+dmFsdWUgPT4gU2V2ZXJpdHk6OldBUk4sCiAqICAgICBMZXZlbDo6RXJyb3ItPnZhbHVlID0+IFNldmVyaXR5OjpFUlJPUiwKICogICAgIExldmVsOjpDcml0aWNhbC0+dmFsdWUgPT4gU2V2ZXJpdHk6OkZBVEFMLAogKiAgICAgTGV2ZWw6OkFsZXJ0LT52YWx1ZSA9PiBTZXZlcml0eTo6RkFUQUwsCiAqICAgICBMZXZlbDo6RW1lcmdlbmN5LT52YWx1ZSA9PiBTZXZlcml0eTo6RkFUQUwsCiAqIF0pOwogKiBgYGAKICov"},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":107,"slug":"log-record-converter","name":"log_record_converter","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[{"name":"severityMapper","type":[{"name":"SeverityMapper","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"valueNormalizer","type":[{"name":"ValueNormalizer","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"LogRecordConverter","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExvZ1JlY29yZENvbnZlcnRlciBmb3IgY29udmVydGluZyBNb25vbG9nIExvZ1JlY29yZCB0byBUZWxlbWV0cnkgTG9nUmVjb3JkLgogKgogKiBUaGUgY29udmVydGVyIGhhbmRsZXM6CiAqIC0gU2V2ZXJpdHkgbWFwcGluZyBmcm9tIE1vbm9sb2cgTGV2ZWwgdG8gVGVsZW1ldHJ5IFNldmVyaXR5CiAqIC0gTWVzc2FnZSBib2R5IGNvbnZlcnNpb24KICogLSBDaGFubmVsIGFuZCBsZXZlbCBuYW1lIGFzIG1vbm9sb2cuKiBhdHRyaWJ1dGVzCiAqIC0gQ29udGV4dCB2YWx1ZXMgYXMgY29udGV4dC4qIGF0dHJpYnV0ZXMgKFRocm93YWJsZXMgdXNlIHNldEV4Y2VwdGlvbigpKQogKiAtIEV4dHJhIHZhbHVlcyBhcyBleHRyYS4qIGF0dHJpYnV0ZXMKICoKICogQHBhcmFtIG51bGx8U2V2ZXJpdHlNYXBwZXIgJHNldmVyaXR5TWFwcGVyIEN1c3RvbSBzZXZlcml0eSBtYXBwZXIgKGRlZmF1bHRzIHRvIHN0YW5kYXJkIG1hcHBpbmcpCiAqIEBwYXJhbSBudWxsfFZhbHVlTm9ybWFsaXplciAkdmFsdWVOb3JtYWxpemVyIEN1c3RvbSB2YWx1ZSBub3JtYWxpemVyIChkZWZhdWx0cyB0byBzdGFuZGFyZCBub3JtYWxpemVyKQogKgogKiBFeGFtcGxlIHVzYWdlOgogKiBgYGBwaHAKICogJGNvbnZlcnRlciA9IGxvZ19yZWNvcmRfY29udmVydGVyKCk7CiAqICR0ZWxlbWV0cnlSZWNvcmQgPSAkY29udmVydGVyLT5jb252ZXJ0KCRtb25vbG9nUmVjb3JkKTsKICogYGBgCiAqCiAqIEV4YW1wbGUgd2l0aCBjdXN0b20gbWFwcGVyOgogKiBgYGBwaHAKICogJGNvbnZlcnRlciA9IGxvZ19yZWNvcmRfY29udmVydGVyKAogKiAgICAgc2V2ZXJpdHlNYXBwZXI6IHNldmVyaXR5X21hcHBlcihbCiAqICAgICAgICAgTGV2ZWw6OkRlYnVnLT52YWx1ZSA9PiBTZXZlcml0eTo6VFJBQ0UsCiAqICAgICBdKQogKiApOwogKiBgYGAKICov"},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":149,"slug":"telemetry-handler","name":"telemetry_handler","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[{"name":"logger","type":[{"name":"Logger","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"converter","type":[{"name":"LogRecordConverter","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Monolog\\Telemetry\\LogRecordConverter::..."},{"name":"level","type":[{"name":"Level","namespace":"Monolog","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Monolog\\Level::..."},{"name":"bubble","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"TelemetryHandler","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRlbGVtZXRyeUhhbmRsZXIgZm9yIGZvcndhcmRpbmcgTW9ub2xvZyBsb2dzIHRvIEZsb3cgVGVsZW1ldHJ5LgogKgogKiBAcGFyYW0gTG9nZ2VyICRsb2dnZXIgVGhlIEZsb3cgVGVsZW1ldHJ5IGxvZ2dlciB0byBmb3J3YXJkIGxvZ3MgdG8KICogQHBhcmFtIExvZ1JlY29yZENvbnZlcnRlciAkY29udmVydGVyIENvbnZlcnRlciB0byB0cmFuc2Zvcm0gTW9ub2xvZyBMb2dSZWNvcmQgdG8gVGVsZW1ldHJ5IExvZ1JlY29yZAogKiBAcGFyYW0gTGV2ZWwgJGxldmVsIFRoZSBtaW5pbXVtIGxvZ2dpbmcgbGV2ZWwgYXQgd2hpY2ggdGhpcyBoYW5kbGVyIHdpbGwgYmUgdHJpZ2dlcmVkCiAqIEBwYXJhbSBib29sICRidWJibGUgV2hldGhlciBtZXNzYWdlcyBoYW5kbGVkIGJ5IHRoaXMgaGFuZGxlciBzaG91bGQgYnViYmxlIHVwIHRvIG90aGVyIGhhbmRsZXJzCiAqCiAqIEV4YW1wbGUgdXNhZ2U6CiAqIGBgYHBocAogKiB1c2UgTW9ub2xvZ1xMb2dnZXIgYXMgTW9ub2xvZ0xvZ2dlcjsKICogdXNlIGZ1bmN0aW9uIEZsb3dcQnJpZGdlXE1vbm9sb2dcVGVsZW1ldHJ5XERTTFx0ZWxlbWV0cnlfaGFuZGxlcjsKICogdXNlIGZ1bmN0aW9uIEZsb3dcVGVsZW1ldHJ5XERTTFx0ZWxlbWV0cnk7CiAqCiAqICR0ZWxlbWV0cnkgPSB0ZWxlbWV0cnkoKTsKICogJGxvZ2dlciA9ICR0ZWxlbWV0cnktPmxvZ2dlcignbXktYXBwJyk7CiAqCiAqICRtb25vbG9nID0gbmV3IE1vbm9sb2dMb2dnZXIoJ2NoYW5uZWwnKTsKICogJG1vbm9sb2ctPnB1c2hIYW5kbGVyKHRlbGVtZXRyeV9oYW5kbGVyKCRsb2dnZXIpKTsKICoKICogJG1vbm9sb2ctPmluZm8oJ1VzZXIgbG9nZ2VkIGluJywgWyd1c2VyX2lkJyA9PiAxMjNdKTsKICogLy8g4oaSIEZvcndhcmRlZCB0byBGbG93IFRlbGVtZXRyeSB3aXRoIElORk8gc2V2ZXJpdHkKICogYGBgCiAqCiAqIEV4YW1wbGUgd2l0aCBjdXN0b20gY29udmVydGVyOgogKiBgYGBwaHAKICogJGNvbnZlcnRlciA9IGxvZ19yZWNvcmRfY29udmVydGVyKAogKiAgICAgc2V2ZXJpdHlNYXBwZXI6IHNldmVyaXR5X21hcHBlcihbCiAqICAgICAgICAgTGV2ZWw6OkRlYnVnLT52YWx1ZSA9PiBTZXZlcml0eTo6VFJBQ0UsCiAqICAgICBdKQogKiApOwogKiAkbW9ub2xvZy0+cHVzaEhhbmRsZXIodGVsZW1ldHJ5X2hhbmRsZXIoJGxvZ2dlciwgJGNvbnZlcnRlcikpOwogKiBgYGAKICov"},{"repository_path":"src\/bridge\/symfony\/http-foundation-telemetry\/src\/Flow\/Bridge\/Symfony\/HttpFoundationTelemetry\/DSL\/functions.php","start_line_in_file":16,"slug":"symfony-request-carrier","name":"symfony_request_carrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry\\DSL","parameters":[{"name":"request","type":[{"name":"Request","namespace":"Symfony\\Component\\HttpFoundation","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestCarrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SYMFONY_HTTP_FOUNDATION_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/symfony\/http-foundation-telemetry\/src\/Flow\/Bridge\/Symfony\/HttpFoundationTelemetry\/DSL\/functions.php","start_line_in_file":22,"slug":"symfony-response-carrier","name":"symfony_response_carrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry\\DSL","parameters":[{"name":"response","type":[{"name":"Response","namespace":"Symfony\\Component\\HttpFoundation","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ResponseCarrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SYMFONY_HTTP_FOUNDATION_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/psr7\/telemetry\/src\/Flow\/Bridge\/Psr7\/Telemetry\/DSL\/functions.php","start_line_in_file":16,"slug":"psr7-request-carrier","name":"psr7_request_carrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry\\DSL","parameters":[{"name":"request","type":[{"name":"ServerRequestInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestCarrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PSR7_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/psr7\/telemetry\/src\/Flow\/Bridge\/Psr7\/Telemetry\/DSL\/functions.php","start_line_in_file":22,"slug":"psr7-response-carrier","name":"psr7_response_carrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry\\DSL","parameters":[{"name":"response","type":[{"name":"ResponseInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ResponseCarrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PSR7_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/psr18\/telemetry\/src\/Flow\/Bridge\/Psr18\/Telemetry\/DSL\/functions.php","start_line_in_file":15,"slug":"psr18-traceable-client","name":"psr18_traceable_client","namespace":"Flow\\Bridge\\Psr18\\Telemetry\\DSL","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"telemetry","type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PSR18TraceableClient","namespace":"Flow\\Bridge\\Psr18\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PSR18_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":49,"slug":"otlp-json-serializer","name":"otlp_json_serializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"JsonSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gc2VyaWFsaXplciBmb3IgT1RMUC4KICoKICogUmV0dXJucyBhIEpzb25TZXJpYWxpemVyIHRoYXQgY29udmVydHMgdGVsZW1ldHJ5IGRhdGEgdG8gT1RMUCBKU09OIHdpcmUgZm9ybWF0LgogKiBVc2UgdGhpcyB3aXRoIEN1cmxUcmFuc3BvcnQgZm9yIEpTT04gb3ZlciBIVFRQLgogKgogKiBFeGFtcGxlIHVzYWdlOgogKiBgYGBwaHAKICogJHNlcmlhbGl6ZXIgPSBvdGxwX2pzb25fc2VyaWFsaXplcigpOwogKiAkdHJhbnNwb3J0ID0gb3RscF9jdXJsX3RyYW5zcG9ydCgkZW5kcG9pbnQsICRzZXJpYWxpemVyKTsKICogYGBgCiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":70,"slug":"otlp-protobuf-serializer","name":"otlp_protobuf_serializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"ProtobufSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFByb3RvYnVmIHNlcmlhbGl6ZXIgZm9yIE9UTFAuCiAqCiAqIFJldHVybnMgYSBQcm90b2J1ZlNlcmlhbGl6ZXIgdGhhdCBjb252ZXJ0cyB0ZWxlbWV0cnkgZGF0YSB0byBPVExQIFByb3RvYnVmIGJpbmFyeSBmb3JtYXQuCiAqIFVzZSB0aGlzIHdpdGggQ3VybFRyYW5zcG9ydCBmb3IgUHJvdG9idWYgb3ZlciBIVFRQLCBvciB3aXRoIEdycGNUcmFuc3BvcnQuCiAqCiAqIFJlcXVpcmVzOgogKiAtIGdvb2dsZS9wcm90b2J1ZiBwYWNrYWdlCiAqCiAqIEV4YW1wbGUgdXNhZ2U6CiAqIGBgYHBocAogKiAkc2VyaWFsaXplciA9IG90bHBfcHJvdG9idWZfc2VyaWFsaXplcigpOwogKiAkdHJhbnNwb3J0ID0gb3RscF9jdXJsX3RyYW5zcG9ydCgkZW5kcG9pbnQsICRzZXJpYWxpemVyKTsKICogYGBgCiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":94,"slug":"otlp-grpc-transport","name":"otlp_grpc_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"endpoint","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"headers","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"insecure","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"timeoutMs","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"250"},{"name":"shutdownTimeoutMs","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"5000"},{"name":"failover","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGdSUEMgdHJhbnNwb3J0IGZvciBPVExQIGVuZHBvaW50cy4KICoKICogQ3JlYXRlcyBhIEdycGNUcmFuc3BvcnQgY29uZmlndXJlZCB0byBzZW5kIHRlbGVtZXRyeSBkYXRhIHRvIGFuIE9UTFAtY29tcGF0aWJsZQogKiBlbmRwb2ludCB1c2luZyBnUlBDIHByb3RvY29sIHdpdGggUHJvdG9idWYgc2VyaWFsaXphdGlvbi4gT1RMUC9nUlBDIG1hbmRhdGVzCiAqIFByb3RvYnVmLCBzbyB0aGUgc2VyaWFsaXplciBpcyBidWlsdCBpbnRlcm5hbGx5IGFuZCBub3QgY29uZmlndXJhYmxlLgogKgogKiBSZXF1aXJlczoKICogLSBleHQtZ3JwYyBQSFAgZXh0ZW5zaW9uCiAqIC0gZ29vZ2xlL3Byb3RvYnVmIHBhY2thZ2UKICoKICogQHBhcmFtIHN0cmluZyAkZW5kcG9pbnQgZ1JQQyBlbmRwb2ludCAoZS5nLiwgJ2xvY2FsaG9zdDo0MzE3JykKICogQHBhcmFtIGFycmF5PHN0cmluZywgc3RyaW5nPiAkaGVhZGVycyBBZGRpdGlvbmFsIGhlYWRlcnMgKG1ldGFkYXRhKSB0byBpbmNsdWRlIGluIHJlcXVlc3RzCiAqIEBwYXJhbSBib29sICRpbnNlY3VyZSBXaGV0aGVyIHRvIHVzZSBpbnNlY3VyZSBjaGFubmVsIGNyZWRlbnRpYWxzIChkZWZhdWx0IHRydWUgZm9yIGxvY2FsIGRldikKICogQHBhcmFtIGludCAkdGltZW91dE1zIFBlci1jYWxsIGRlYWRsaW5lIGluIG1pbGxpc2Vjb25kcyAoY292ZXJzIGNvbm5lY3QgKyBzZW5kICsgcmVjZWl2ZSkKICogQHBhcmFtIGludCAkc2h1dGRvd25UaW1lb3V0TXMgV2FsbC1jbG9jayBidWRnZXQgZm9yIGRyYWluaW5nIHBlbmRpbmcgY2FsbHMgYXQgc2h1dGRvd24KICogQHBhcmFtID9UcmFuc3BvcnQgJGZhaWxvdmVyIE9wdGlvbmFsIGZhaWxvdmVyIHRyYW5zcG9ydCByZWNlaXZpbmcgcHJpb3IgYmF0Y2hlcyB3aGVuIHByaW1hcnkgZmFpbHMKICov"},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":109,"slug":"otlp-curl-options","name":"otlp_curl_options","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"CurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjdXJsIHRyYW5zcG9ydCBvcHRpb25zIGZvciBPVExQLgogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":130,"slug":"otlp-curl-transport","name":"otlp_curl_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"endpoint","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"serializer","type":[{"name":"JsonSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false},{"name":"ProtobufSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer\\JsonSerializer::..."},{"name":"options","type":[{"name":"CurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Transport\\CurlTransportOptions::..."},{"name":"failover","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHN5bmNocm9ub3VzIGN1cmwgdHJhbnNwb3J0IGZvciBPVExQIGVuZHBvaW50cy4KICoKICogQ3JlYXRlcyBhIEN1cmxUcmFuc3BvcnQgdGhhdCBkcml2ZXMgZWFjaCByZXF1ZXN0IHRvIGNvbXBsZXRpb24gYW5kIHJlcG9ydHMgdGhlCiAqIG91dGNvbWUgaW1tZWRpYXRlbHkgKHJldHVybnMgb24gc3VjY2VzcywgdGhyb3dzIG9uIGZhaWx1cmUpLiBPVExQL0hUVFAgYWxsb3dzCiAqIEpTT04gb3IgUHJvdG9idWYgZW5jb2Rpbmc7IGRlZmF1bHRzIHRvIEpTT04uIEtlZXBpbmcgZXhwb3J0IG9mZiB0aGUgYXBwbGljYXRpb24KICogaG90IHBhdGggaXMgdGhlIGpvYiBvZiB0aGUgYmF0Y2hpbmcgcHJvY2Vzc29yIGluIGZyb250IG9mIHRoZSBleHBvcnRlci4KICoKICogUmVxdWlyZXM6IGV4dC1jdXJsIFBIUCBleHRlbnNpb24KICoKICogQHBhcmFtIHN0cmluZyAkZW5kcG9pbnQgT1RMUCBlbmRwb2ludCBVUkwgKGUuZy4sICdodHRwOi8vbG9jYWxob3N0OjQzMTgnKQogKiBAcGFyYW0gSnNvblNlcmlhbGl6ZXJ8UHJvdG9idWZTZXJpYWxpemVyICRzZXJpYWxpemVyIFNlcmlhbGl6ZXIgZm9yIGVuY29kaW5nIHRlbGVtZXRyeSBkYXRhIChKU09OIG9yIFByb3RvYnVmKQogKiBAcGFyYW0gQ3VybFRyYW5zcG9ydE9wdGlvbnMgJG9wdGlvbnMgVHJhbnNwb3J0IGNvbmZpZ3VyYXRpb24gb3B0aW9ucwogKiBAcGFyYW0gP1RyYW5zcG9ydCAkZmFpbG92ZXIgT3B0aW9uYWwgZmFpbG92ZXIgdHJhbnNwb3J0IHJlY2VpdmluZyB0aGUgYmF0Y2ggd2hlbiB0aGUgcHJpbWFyeSBmYWlscwogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":143,"slug":"otlp-async-curl-options","name":"otlp_async_curl_options","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"AsyncCurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhc3luYyBjdXJsIHRyYW5zcG9ydCBvcHRpb25zIGZvciBPVExQLgogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":158,"slug":"otlp-async-curl-transport","name":"otlp_async_curl_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"endpoint","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"serializer","type":[{"name":"JsonSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false},{"name":"ProtobufSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer\\JsonSerializer::..."},{"name":"options","type":[{"name":"AsyncCurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Transport\\AsyncCurlTransportOptions::..."},{"name":"failover","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"error_handler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"AsyncCurlTransport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhc3luY2hyb25vdXMgY3VybCB0cmFuc3BvcnQgZm9yIE9UTFAgZW5kcG9pbnRzLgogKgogKiBAcGFyYW0gc3RyaW5nICRlbmRwb2ludCBPVExQIGVuZHBvaW50IFVSTCAoZS5nLiwgJ2h0dHA6Ly9sb2NhbGhvc3Q6NDMxOCcpCiAqIEBwYXJhbSBKc29uU2VyaWFsaXplcnxQcm90b2J1ZlNlcmlhbGl6ZXIgJHNlcmlhbGl6ZXIgU2VyaWFsaXplciBmb3IgZW5jb2RpbmcgdGVsZW1ldHJ5IGRhdGEgKEpTT04gb3IgUHJvdG9idWYpCiAqIEBwYXJhbSBBc3luY0N1cmxUcmFuc3BvcnRPcHRpb25zICRvcHRpb25zIFRyYW5zcG9ydCBjb25maWd1cmF0aW9uIG9wdGlvbnMKICogQHBhcmFtID9UcmFuc3BvcnQgJGZhaWxvdmVyIE9wdGlvbmFsIGZhaWxvdmVyIHRyYW5zcG9ydCByZWNlaXZpbmcgcHJpb3IgYmF0Y2hlcyB3aGVuIHByaW1hcnkgZmFpbHMKICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JfaGFuZGxlciBIYW5kbGVyIGZvciBmYWlsdXJlcyByZWFwZWQgb24gc2VuZCgpL3RpY2soKS9zaHV0ZG93bigpIChubyBmYWlsb3ZlcikKICov"},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":180,"slug":"otlp-stream-transport","name":"otlp_stream_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"destination","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filePermissions","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"420"},{"name":"createDirectories","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHN0cmVhbSB0cmFuc3BvcnQgZm9yIE9UTFAgdGhhdCB3cml0ZXMgSlNPTkwgdG8gYSBzaW5nbGUgZGVzdGluYXRpb24uCiAqCiAqIEFjY2VwdHMgYW4gYWJzb2x1dGUgZmlsZSBwYXRoIG9yIGEgcGhwOi8vIHN0cmVhbSB3cmFwcGVyIHN1Y2ggYXMKICogJ3BocDovL3N0ZG91dCcsICdwaHA6Ly9zdGRlcnInLCAncGhwOi8vbWVtb3J5Jywgb3IgJ3BocDovL3RlbXAnLiBFYWNoCiAqIGV4cG9ydCgpIGNhbGwgYXBwZW5kcyBvbmUgSlNPTiBMaW5lIHVuZGVyIExPQ0tfRVggc28gY29uY3VycmVudCB3cml0ZXJzCiAqIGludGVybGVhdmUgYXQgbGluZSBib3VuZGFyaWVzLiBUaGUgJGZpbGVQZXJtaXNzaW9ucyBhbmQgJGNyZWF0ZURpcmVjdG9yaWVzCiAqIHBhcmFtZXRlcnMgYXBwbHkgb25seSB3aGVuIHRoZSBkZXN0aW5hdGlvbiBpcyBhIGZpbGUgcGF0aC4KICoKICogUGVyIHRoZSBPVExQIEZpbGUgRXhwb3J0ZXIgc3BlYyBvbmx5IEpTT04gZW5jb2RpbmcgaXMgc3VwcG9ydGVkLgogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":203,"slug":"otlp-exporter","name":"otlp_exporter","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"transport","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"OTLPExporter","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Exporter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPVExQIGV4cG9ydGVyIHRoYXQgZGlzcGF0Y2hlcyBsb2dzLCBtZXRyaWNzLCBhbmQgc3BhbnMgdGhyb3VnaCBhIHNpbmdsZSB0cmFuc3BvcnQuCiAqCiAqIEV4YW1wbGUgdXNhZ2U6CiAqIGBgYHBocAogKiAkZXhwb3J0ZXIgPSBvdGxwX2V4cG9ydGVyKCR0cmFuc3BvcnQpOwogKiAkc3BhblByb2Nlc3NvciA9IGJhdGNoaW5nX3NwYW5fcHJvY2Vzc29yKCRleHBvcnRlcik7CiAqICRtZXRyaWNQcm9jZXNzb3IgPSBiYXRjaGluZ19tZXRyaWNfcHJvY2Vzc29yKCRleHBvcnRlcik7CiAqICRsb2dQcm9jZXNzb3IgPSBiYXRjaGluZ19sb2dfcHJvY2Vzc29yKCRleHBvcnRlcik7CiAqIGBgYAogKgogKiBAcGFyYW0gVHJhbnNwb3J0ICR0cmFuc3BvcnQgVGhlIHRyYW5zcG9ydCBmb3Igc2VuZGluZyB0ZWxlbWV0cnkgZGF0YQogKiBAcGFyYW0gRXJyb3JIYW5kbGVyICRlcnJvckhhbmRsZXIgSGFuZGxlciBmb3IgVGhyb3dhYmxlcyByYWlzZWQgYnkgdGhlIHRyYW5zcG9ydAogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":217,"slug":"otlp-tracer-provider","name":"otlp_tracer_provider","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"processor","type":[{"name":"SpanProcessor","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sampler","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\ParentBasedSampler::..."},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Context\\MemoryContextStorage::..."}],"return_type":[{"name":"TracerProvider","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRyYWNlciBwcm92aWRlciBjb25maWd1cmVkIGZvciBPVExQIGV4cG9ydC4KICoKICogQHBhcmFtIFNwYW5Qcm9jZXNzb3IgJHByb2Nlc3NvciBUaGUgcHJvY2Vzc29yIGZvciBoYW5kbGluZyBzcGFucwogKiBAcGFyYW0gQ2xvY2tJbnRlcmZhY2UgJGNsb2NrIFRoZSBjbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gU2FtcGxlciAkc2FtcGxlciBUaGUgc2FtcGxlciBmb3IgZGVjaWRpbmcgd2hldGhlciB0byByZWNvcmQgc3BhbnMKICogQHBhcmFtIENvbnRleHRTdG9yYWdlICRjb250ZXh0U3RvcmFnZSBUaGUgY29udGV4dCBzdG9yYWdlIGZvciBwcm9wYWdhdGluZyB0cmFjZSBjb250ZXh0CiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":234,"slug":"otlp-meter-provider","name":"otlp_meter_provider","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"processor","type":[{"name":"MetricProcessor","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"temporality","type":[{"name":"AggregationTemporality","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\AggregationTemporality::..."}],"return_type":[{"name":"MeterProvider","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG1ldGVyIHByb3ZpZGVyIGNvbmZpZ3VyZWQgZm9yIE9UTFAgZXhwb3J0LgogKgogKiBAcGFyYW0gTWV0cmljUHJvY2Vzc29yICRwcm9jZXNzb3IgVGhlIHByb2Nlc3NvciBmb3IgaGFuZGxpbmcgbWV0cmljcwogKiBAcGFyYW0gQ2xvY2tJbnRlcmZhY2UgJGNsb2NrIFRoZSBjbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gQWdncmVnYXRpb25UZW1wb3JhbGl0eSAkdGVtcG9yYWxpdHkgVGhlIGFnZ3JlZ2F0aW9uIHRlbXBvcmFsaXR5IGZvciBtZXRyaWNzCiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":250,"slug":"otlp-logger-provider","name":"otlp_logger_provider","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"processor","type":[{"name":"LogProcessor","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Context\\MemoryContextStorage::..."}],"return_type":[{"name":"LoggerProvider","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxvZ2dlciBwcm92aWRlciBjb25maWd1cmVkIGZvciBPVExQIGV4cG9ydC4KICoKICogQHBhcmFtIExvZ1Byb2Nlc3NvciAkcHJvY2Vzc29yIFRoZSBwcm9jZXNzb3IgZm9yIGhhbmRsaW5nIGxvZyByZWNvcmRzCiAqIEBwYXJhbSBDbG9ja0ludGVyZmFjZSAkY2xvY2sgVGhlIGNsb2NrIGZvciB0aW1lc3RhbXBzCiAqIEBwYXJhbSBDb250ZXh0U3RvcmFnZSAkY29udGV4dFN0b3JhZ2UgVGhlIGNvbnRleHQgc3RvcmFnZSBmb3IgcHJvcGFnYXRpbmcgY29udGV4dAogKi8="}]
\ No newline at end of file
+[{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":276,"slug":"df","name":"df","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"ConfigBuilder","namespace":"Flow\\ETL\\Config","is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Flow","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"overwrite"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBkYXRhX2ZyYW1lKCkgOiBGbG93LgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":284,"slug":"data-frame","name":"data_frame","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"ConfigBuilder","namespace":"Flow\\ETL\\Config","is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Flow","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"overwrite"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":290,"slug":"telemetry-options","name":"telemetry_options","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"trace_loading","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"trace_transformations","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"trace_cache","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"collect_metrics","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"TelemetryOptions","namespace":"Flow\\ETL\\Config\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":302,"slug":"from-rows","name":"from_rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"rows","type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"RowsExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"overwrite"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":309,"slug":"from-path-partitions","name":"from_path_partitions","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"PathPartitionsExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"partitioning","example":"path_partitions"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":325,"slug":"from-array","name":"from_array","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"iterable","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."},{"name":"spillRoot","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ArrayExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"array"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"data_frame"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpdGVyYWJsZTxhcnJheTxtaXhlZD4+ICRhcnJheQogKiBAcGFyYW0gbnVsbHxTY2hlbWEgJHNjaGVtYSAtIEBkZXByZWNhdGVkIHVzZSB3aXRoU2NoZW1hKCkgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIG51bGx8UGF0aCAkc3BpbGxSb290IC0gd2hlcmUgYSBub24tYXJyYXkgJGFycmF5IGlzIHNwaWxsZWQgd2hpbGUgaXQgaXMgZGVzY3JpYmVkOyBudWxsIHJlc29sdmVzIHRvCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAkZmlsZXN5c3RlbS0+Z2V0U3lzdGVtVG1wRGlyKCkgYW5kIG9ubHkgb24gdGhhdCBwYXRoCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":346,"slug":"from-cache","name":"from_cache","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"id","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"fallback_extractor","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"clear","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"cache","type":[{"name":"Cache","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CacheExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBzdHJpbmcgJGlkIC0gY2FjaGUgaWQgZnJvbSB3aGljaCBkYXRhIHdpbGwgYmUgZXh0cmFjdGVkCiAqIEBwYXJhbSBudWxsfEV4dHJhY3RvciAkZmFsbGJhY2tfZXh0cmFjdG9yIC0gZXh0cmFjdG9yIHRoYXQgd2lsbCBiZSB1c2VkIHdoZW4gY2FjaGUgaXMgZW1wdHkgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aEZhbGxiYWNrRXh0cmFjdG9yKCkgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIGJvb2wgJGNsZWFyIC0gY2xlYXIgY2FjaGUgYWZ0ZXIgZXh0cmFjdGlvbiAtIEBkZXByZWNhdGVkIHVzZSB3aXRoQ2xlYXJPbkZpbmlzaCgpIG1ldGhvZCBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":366,"slug":"from-all","name":"from_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"extractors","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ChainExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":372,"slug":"from-memory","name":"from_memory","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"memory","type":[{"name":"Memory","namespace":"Flow\\ETL\\Memory","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MemoryExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":378,"slug":"files","name":"files","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"directory","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FilesExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":384,"slug":"filesystem-cache","name":"filesystem_cache","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"serializer","type":[{"name":"Serializer","namespace":"Flow\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"cache_dir","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FilesystemCache","namespace":"Flow\\ETL\\Cache\\Implementation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":396,"slug":"batched-by","name":"batched_by","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"extractor","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"column","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"min_size","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"BatchByExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBudWxsfGludDwxLCBtYXg+ICRtaW5fc2l6ZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":410,"slug":"batches","name":"batches","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"extractor","type":[{"name":"Extractor","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BatchExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpbnQ8MSwgbWF4PiAkc2l6ZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":416,"slug":"from-data-frame","name":"from_data_frame","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"data_frame","type":[{"name":"DataFrame","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DataFrameExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":422,"slug":"from-sequence-date-period","name":"from_sequence_date_period","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"SequenceExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":436,"slug":"from-sequence-date-period-recurrences","name":"from_sequence_date_period_recurrences","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"recurrences","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"SequenceExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":450,"slug":"from-sequence-number","name":"from_sequence_number","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"step","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"}],"return_type":[{"name":"SequenceExtractor","namespace":"Flow\\ETL\\Extractor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":460,"slug":"to-memory","name":"to_memory","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"memory","type":[{"name":"Memory","namespace":"Flow\\ETL\\Memory","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MemoryLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":474,"slug":"to-array","name":"to_array","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"array"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgcm93cyB0byBhbiBhcnJheSBhbmQgc3RvcmUgdGhlbSBpbiBwYXNzZWQgYXJyYXkgdmFyaWFibGUuCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPiAkYXJyYXkKICoKICogQHBhcmFtLW91dCBhcnJheTxhcnJheTxtaXhlZD4+ICRhcnJheQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":482,"slug":"to-output","name":"to_output","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":492,"slug":"to-stderr","name":"to_stderr","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":502,"slug":"to-stdout","name":"to_stdout","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":512,"slug":"to-stream","name":"to_stream","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"uri","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"20"},{"name":"output","type":[{"name":"Output","namespace":"Flow\\ETL\\Loader\\StreamLoader","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Loader\\StreamLoader\\Output::..."},{"name":"mode","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'w'"},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Formatter\\AsciiTableFormatter::..."},{"name":"schemaFormatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\Formatter\\ASCIISchemaFormatter::..."}],"return_type":[{"name":"StreamLoader","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":532,"slug":"to-transformation","name":"to_transformation","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"transformer","type":[{"name":"Transformer","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Transformation","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sink","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Transformed","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":538,"slug":"to-branch","name":"to_branch","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"condition","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sink","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Branched","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":544,"slug":"rename-style","name":"rename_style","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"style","type":[{"name":"StringStyles","namespace":"Flow\\ETL\\String","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RenameCaseEntryStrategy","namespace":"Flow\\ETL\\Transformer\\Rename","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":554,"slug":"rename-replace","name":"rename_replace","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"search","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"replace","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RenameReplaceEntryStrategy","namespace":"Flow\\ETL\\Transformer\\Rename","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+fHN0cmluZyAkc2VhcmNoCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+fHN0cmluZyAkcmVwbGFjZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":563,"slug":"rename-map","name":"rename_map","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"renames","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RenameMapEntryStrategy","namespace":"Flow\\ETL\\Transformer\\Rename","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIHN0cmluZz4gJHJlbmFtZXMgTWFwIG9mIG9sZF9uYW1lID0+IG5ld19uYW1lCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":569,"slug":"rows","name":"rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"backend","type":[{"name":"Backend","namespace":"Flow\\ETL\\Column","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Column\\AdaptiveBackend::..."}],"return_type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":578,"slug":"col","name":"col","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnresolvedReference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFuIGFsaWFzIGZvciBgcmVmYC4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":588,"slug":"entry","name":"entry","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnresolvedReference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"columns","example":"create"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFuIGFsaWFzIGZvciBgcmVmYC4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":595,"slug":"ref","name":"ref","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnresolvedReference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"columns","example":"create"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":601,"slug":"structure-ref","name":"structure_ref","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StructureFunctions","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":613,"slug":"structure","name":"structure","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Structure","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEJ1aWxkcyBhIHN0cnVjdHVyZSBmcm9tIHNjYWxhciBmdW5jdGlvbnM6IG9uZSBlbGVtZW50IHBlciBrZXksIGluIGtleSBvcmRlci4KICogQW4gZWxlbWVudCBpcyBudWxsYWJsZSB3aGVuIGl0cyBmdW5jdGlvbiBpczsgdGhlIHN0cnVjdHVyZSBpdHNlbGYgbmV2ZXIgaXMuCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIFNjYWxhckZ1bmN0aW9uPiAkZWxlbWVudHMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":619,"slug":"list-ref","name":"list_ref","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ListFunctions","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":625,"slug":"refs","name":"refs","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":631,"slug":"select","name":"select","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Select","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":637,"slug":"drop","name":"drop","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Drop","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":643,"slug":"add-row-index","name":"add_row_index","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'index'"},{"name":"startFrom","type":[{"name":"StartFrom","namespace":"Flow\\ETL\\Transformation\\AddRowIndex","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Transformation\\AddRowIndex\\StartFrom::..."}],"return_type":[{"name":"AddRowIndex","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":652,"slug":"batch-size","name":"batch_size","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BatchSize","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpbnQ8MSwgbWF4PiAkc2l6ZQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":658,"slug":"limit","name":"limit","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Limit","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":667,"slug":"mask-columns","name":"mask_columns","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"mask","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'******'"}],"return_type":[{"name":"MaskColumns","namespace":"Flow\\ETL\\Transformation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"TRANSFORMER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxpbnQsIHN0cmluZz4gJGNvbHVtbnMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":673,"slug":"optional","name":"optional","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Optional","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":680,"slug":"lit","name":"lit","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Literal","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"columns","example":"create"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":686,"slug":"exists","name":"exists","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Exists","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":692,"slug":"when","name":"when","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"condition","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"then","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"else","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"When","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":701,"slug":"structure-get","name":"structure_get","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGet","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgYXJyYXlfZ2V0YC4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":707,"slug":"array-get","name":"array_get","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGet","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":718,"slug":"structure-get-collection","name":"structure_get_collection","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgYXJyYXlfZ2V0X2NvbGxlY3Rpb25gLgogKgogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58U2NhbGFyRnVuY3Rpb24gJGtleXMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":727,"slug":"array-get-collection","name":"array_get_collection","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAka2V5cwogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":736,"slug":"structure-get-collection-first","name":"structure_get_collection_first","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgYXJyYXlfZ2V0X2NvbGxlY3Rpb25fZmlyc3RgLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":742,"slug":"array-get-collection-first","name":"array_get_collection_first","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ArrayGetCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":751,"slug":"array-exists","name":"array_exists","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayPathExists","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkcmVmCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":761,"slug":"array-merge","name":"array_merge","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"left","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayMerge","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkbGVmdAogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58U2NhbGFyRnVuY3Rpb24gJHJpZ2h0CiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":770,"slug":"array-merge-collection","name":"array_merge_collection","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayMergeCollection","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkYXJyYXkKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":776,"slug":"array-key-rename","name":"array_key_rename","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"newName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayKeyRename","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":782,"slug":"array-keys-style-convert","name":"array_keys_style_convert","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"style","type":[{"name":"StringStyles","namespace":"Flow\\ETL\\String","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\String\\StringStyles::..."}],"return_type":[{"name":"ArrayKeysStyleConvert","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":790,"slug":"array-sort","name":"array_sort","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sort_function","type":[{"name":"Sort","namespace":"Flow\\ETL\\Function\\ArraySort","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"flags","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"recursive","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"ArraySort","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":803,"slug":"array-reverse","name":"array_reverse","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"preserveKeys","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"ArrayReverse","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkZnVuY3Rpb24KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":809,"slug":"now","name":"now","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"time_zone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"DateTimeZone::..."}],"return_type":[{"name":"Now","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":815,"slug":"between","name":"between","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"lower_bound","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"upper_bound","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"boundary","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"Boundary","namespace":"Flow\\ETL\\Function\\Between","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Function\\Between\\Boundary::..."}],"return_type":[{"name":"Between","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":825,"slug":"to-date-time","name":"to_date_time","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"format","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d H:i:s'"},{"name":"timeZone","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"DateTimeZone::..."}],"return_type":[{"name":"ToDateTime","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":834,"slug":"to-date","name":"to_date","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"format","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d'"},{"name":"timeZone","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"DateTimeZone::..."}],"return_type":[{"name":"ToDate","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":843,"slug":"date-time-format","name":"date_time_format","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DateTimeFormat","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":849,"slug":"split","name":"split","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"9223372036854775807"}],"return_type":[{"name":"Split","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":862,"slug":"combine","name":"combine","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"keys","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"values","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Combine","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAka2V5cwogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58U2NhbGFyRnVuY3Rpb24gJHZhbHVlcwogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":871,"slug":"concat","name":"concat","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"functions","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Concat","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIENvbmNhdCBhbGwgdmFsdWVzLiBJZiB5b3Ugd2FudCB0byBjb25jYXRlbmF0ZSB2YWx1ZXMgd2l0aCBzZXBhcmF0b3IgdXNlIGNvbmNhdF93cyBmdW5jdGlvbi4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":880,"slug":"concat-ws","name":"concat_ws","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"functions","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ConcatWithSeparator","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIENvbmNhdCBhbGwgdmFsdWVzIHdpdGggc2VwYXJhdG9yLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":886,"slug":"hash","name":"hash","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"algorithm","type":[{"name":"Algorithm","namespace":"Flow\\ETL\\Hash","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Hash\\NativePHPHash::..."}],"return_type":[{"name":"Hash","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":895,"slug":"cast","name":"cast","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Cast","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBcRmxvd1xUeXBlc1xUeXBlPG1peGVkPnxzdHJpbmcgJHR5cGUKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":901,"slug":"coalesce","name":"coalesce","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Coalesce","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":907,"slug":"enum-name","name":"enum_name","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnumName","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":913,"slug":"enum-value","name":"enum_value","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnumValue","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":919,"slug":"count","name":"count","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Count","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":931,"slug":"call","name":"call","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"callable","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"return_type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"CallUserFunc","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIENhbGxzIGEgdXNlci1kZWZpbmVkIGZ1bmN0aW9uIHdpdGggdGhlIGdpdmVuIHBhcmFtZXRlcnMuCiAqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAkcmV0dXJuX3R5cGUKICogQHBhcmFtIGFycmF5PG1peGVkPiAkcGFyYW1ldGVycwogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":958,"slug":"array-unpack","name":"array_unpack","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"array","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayUnpack","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIFVucGFja3MgZWFjaCBlbGVtZW50IG9mIGFuIGFycmF5IGludG8gYSBuZXcgZW50cnksIHVzaW5nIHRoZSBhcnJheSBrZXkgYXMgdGhlIGVudHJ5IG5hbWUuCiAqCiAqIEJlZm9yZToKICogKy0tKy0tLS0tLS0tLS0tLS0tLS0tLS0rCiAqIHxpZHwgICAgICAgICAgICAgIGFycmF5fAogKiArLS0rLS0tLS0tLS0tLS0tLS0tLS0tLSsKICogfCAxfHsiYSI6MSwiYiI6MiwiYyI6M318CiAqIHwgMnx7ImQiOjQsImUiOjUsImYiOjZ9fAogKiArLS0rLS0tLS0tLS0tLS0tLS0tLS0tLSsKICoKICogQWZ0ZXI6CiAqICstLSstLS0tLSstLS0tLSstLS0tLSstLS0tLSstLS0tLSsKICogfGlkfGFyci5ifGFyci5jfGFyci5kfGFyci5lfGFyci5mfAogKiArLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rCiAqIHwgMXwgICAgMnwgICAgM3wgICAgIHwgICAgIHwgICAgIHwKICogfCAyfCAgICAgfCAgICAgfCAgICA0fCAgICA1fCAgICA2fAogKiArLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rLS0tLS0rCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIG1peGVkPnxTY2FsYXJGdW5jdGlvbiAkYXJyYXkKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":988,"slug":"array-expand","name":"array_expand","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"expand","type":[{"name":"ArrayExpand","namespace":"Flow\\ETL\\Function\\ArrayExpand","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Function\\ArrayExpand\\ArrayExpand::..."}],"return_type":[{"name":"ArrayExpand","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEV4cGFuZHMgZWFjaCB2YWx1ZSBpbnRvIGVudHJ5LCBpZiB0aGVyZSBhcmUgbW9yZSB0aGFuIG9uZSB2YWx1ZSwgbXVsdGlwbGUgcm93cyB3aWxsIGJlIGNyZWF0ZWQuCiAqIEFycmF5IGtleXMgYXJlIGlnbm9yZWQsIG9ubHkgdmFsdWVzIGFyZSB1c2VkIHRvIGNyZWF0ZSBuZXcgcm93cy4KICogTmVzdGVkIGluIGFub3RoZXIgZnVuY3Rpb24gKHN0cnVjdHVyZSgpLCBjb25jYXQoKSwgLi4uKSBpdCBzdGlsbCBnaXZlcyBvbmUgcm93IHBlciBlbGVtZW50LiBTZXZlcmFsCiAqIGV4cGFuZHMgaW4gb25lIGV4cHJlc3Npb24gYXJlIHppcHBlZCB0byB0aGUgbG9uZ2VzdCBsaXN0OyBhIHNob3J0ZXIgb25lIGdpdmVzIG51bGwsIHNvIGl0cyBlbGVtZW50CiAqIHR5cGUgYmVjb21lcyBudWxsYWJsZS4gSXQgaXMgcmVmdXNlZCBpbnNpZGUgYW5vdGhlciBhcnJheV9leHBhbmQoKSBhbmQgaW4gZmlsdGVyKCksIHVudGlsKCksCiAqIGR1cGxpY2F0ZVJvdygpLCBhZ2dyZWdhdGUoKSwgb3ZlcigpIGFuZCBvbkVhY2goKS4KICoKICogQmVmb3JlOgogKiAgICstLSstLS0tLS0tLS0tLS0tLS0tLS0tKwogKiAgIHxpZHwgICAgICAgICAgICAgIGFycmF5fAogKiAgICstLSstLS0tLS0tLS0tLS0tLS0tLS0tKwogKiAgIHwgMXx7ImEiOjEsImIiOjIsImMiOjN9fAogKiAgICstLSstLS0tLS0tLS0tLS0tLS0tLS0tKwogKgogKiBBZnRlcjoKICogICArLS0rLS0tLS0tLS0rCiAqICAgfGlkfGV4cGFuZGVkfAogKiAgICstLSstLS0tLS0tLSsKICogICB8IDF8ICAgICAgIDF8CiAqICAgfCAxfCAgICAgICAyfAogKiAgIHwgMXwgICAgICAgM3wKICogICArLS0rLS0tLS0tLS0rCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":994,"slug":"size","name":"size","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Size","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1000,"slug":"uuid-v4","name":"uuid_v4","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Uuid","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1006,"slug":"uuid-v7","name":"uuid_v7","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Uuid","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1012,"slug":"ulid","name":"ulid","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Ulid","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1018,"slug":"lower","name":"lower","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ToLower","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1024,"slug":"capitalize","name":"capitalize","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Capitalize","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1030,"slug":"upper","name":"upper","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ToUpper","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1036,"slug":"all","name":"all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"functions","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1042,"slug":"any","name":"any","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1048,"slug":"not","name":"not","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Not","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1054,"slug":"to-timezone","name":"to_timezone","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"timeZone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ToTimeZone","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1060,"slug":"ignore-error-handler","name":"ignore_error_handler","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"IgnoreError","namespace":"Flow\\ETL\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1066,"slug":"skip-rows-handler","name":"skip_rows_handler","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SkipRows","namespace":"Flow\\ETL\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1072,"slug":"throw-error-handler","name":"throw_error_handler","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"ThrowError","namespace":"Flow\\ETL\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1078,"slug":"regex-replace","name":"regex_replace","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"replacement","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"RegexReplace","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1088,"slug":"regex-match-all","name":"regex_match_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"RegexMatchAll","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1098,"slug":"regex-match","name":"regex_match","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"RegexMatch","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1108,"slug":"regex","name":"regex","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"Regex","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1118,"slug":"regex-all","name":"regex_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"pattern","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"subject","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"offset","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"RegexAll","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1128,"slug":"sprintf","name":"sprintf","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"format","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Sprintf","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1134,"slug":"sanitize","name":"sanitize","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"placeholder","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'*'"},{"name":"skipCharacters","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Sanitize","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1143,"slug":"round","name":"round","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2"},{"name":"mode","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"}],"return_type":[{"name":"Round","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1152,"slug":"number-format","name":"number_format","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"value","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"decimals","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2"},{"name":"decimal_separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'.'"},{"name":"thousands_separator","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"','"}],"return_type":[{"name":"NumberFormat","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1165,"slug":"array-to-rows","name":"array_to_rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"backend","type":[{"name":"Backend","namespace":"Flow\\ETL\\Column","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Column\\AdaptiveBackend::..."}],"return_type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxhcnJheTxtaXhlZD4+fGFycmF5PG1peGVkfHN0cmluZz4gJGRhdGEKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1173,"slug":"rank","name":"rank","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Rank","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"WINDOW_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1179,"slug":"dens-rank","name":"dens_rank","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"DenseRank","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"WINDOW_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1185,"slug":"dense-rank","name":"dense_rank","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"DenseRank","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"WINDOW_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1191,"slug":"average","name":"average","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2"},{"name":"rounding","type":[{"name":"Rounding","namespace":"Flow\\Calculator","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Calculator\\Rounding::..."},{"name":"exact","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Average","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1201,"slug":"greatest","name":"greatest","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Greatest","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1207,"slug":"least","name":"least","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Least","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1213,"slug":"collect","name":"collect","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Collect","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1219,"slug":"string-agg","name":"string_agg","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"', '"},{"name":"sort","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StringAggregate","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1225,"slug":"collect-unique","name":"collect_unique","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CollectUnique","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1231,"slug":"window","name":"window","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Window","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1237,"slug":"unbounded-preceding","name":"unbounded_preceding","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1243,"slug":"preceding","name":"preceding","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1249,"slug":"current-row","name":"current_row","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1255,"slug":"following","name":"following","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1261,"slug":"unbounded-following","name":"unbounded_following","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\ETL\\Window","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1267,"slug":"sum","name":"sum","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"exact","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Sum","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1273,"slug":"first","name":"first","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"First","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1279,"slug":"last","name":"last","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Last","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1285,"slug":"max","name":"max","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Max","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1291,"slug":"min","name":"min","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Min","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"AGGREGATING_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1297,"slug":"row-number","name":"row_number","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"RowNumber","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1308,"slug":"schema","name":"schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"definitions","type":[{"name":"Definition","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBEZWZpbml0aW9uPG1peGVkPiAuLi4kZGVmaW5pdGlvbnMKICoKICogQHJldHVybiBTY2hlbWEKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1317,"slug":"schema-to-json","name":"schema_to_json","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pretty","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1326,"slug":"schema-to-php","name":"schema_to_php","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"valueFormatter","type":[{"name":"ValueFormatter","namespace":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter\\ValueFormatter::..."},{"name":"typeFormatter","type":[{"name":"TypeFormatter","namespace":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Schema\\Formatter\\PHPFormatter\\TypeFormatter::..."}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1338,"slug":"schema-to-ascii","name":"schema_to_ascii","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"formatter","type":[{"name":"SchemaFormatter","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1348,"slug":"schema-validate","name":"schema_validate","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"expected","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"given","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"validator","type":[{"name":"SchemaValidator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Schema\\Validator\\StrictValidator::..."}],"return_type":[{"name":"ValidationContext","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTY2hlbWEgJGV4cGVjdGVkCiAqIEBwYXJhbSBTY2hlbWEgJGdpdmVuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1357,"slug":"schema-evolving-validator","name":"schema_evolving_validator","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"EvolvingValidator","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1363,"slug":"schema-strict-validator","name":"schema_strict_validator","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"StrictValidator","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1369,"slug":"schema-selective-validator","name":"schema_selective_validator","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SelectiveValidator","namespace":"Flow\\ETL\\Schema\\Validator","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1378,"slug":"schema-from-json","name":"schema_from_json","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gU2NoZW1hCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1391,"slug":"schema-metadata","name":"schema_metadata","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"metadata","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIGFycmF5PGJvb2x8ZmxvYXR8aW50fHN0cmluZz58Ym9vbHxmbG9hdHxpbnR8c3RyaW5nPiAkbWV0YWRhdGEKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1400,"slug":"int-schema","name":"int_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"IntegerDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgaW50ZWdlcl9zY2hlbWFgLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1406,"slug":"integer-schema","name":"integer_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"IntegerDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1415,"slug":"str-schema","name":"str_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StringDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBgc3RyaW5nX3NjaGVtYWAuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1421,"slug":"string-schema","name":"string_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StringDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1427,"slug":"bool-schema","name":"bool_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"BooleanDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1433,"slug":"float-schema","name":"float_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FloatDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1447,"slug":"map-schema","name":"map_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"MapType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MapDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUS2V5IG9mIGFycmF5LWtleQogKiBAdGVtcGxhdGUgVFZhbHVlCiAqCiAqIEBwYXJhbSBNYXBUeXBlPFRLZXksIFRWYWx1ZT58VHlwZTxhcnJheTxUS2V5LCBUVmFsdWU+PiAkdHlwZQogKgogKiBAcmV0dXJuIE1hcERlZmluaXRpb248VEtleSwgVFZhbHVlPgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1461,"slug":"list-schema","name":"list_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ListType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ListDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBMaXN0VHlwZTxUPnxUeXBlPGxpc3Q8VD4+ICR0eXBlCiAqCiAqIEByZXR1cm4gTGlzdERlZmluaXRpb248VD4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1479,"slug":"enum-schema","name":"enum_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"EnumDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIFxVbml0RW51bQogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICR0eXBlCiAqCiAqIEByZXR1cm4gRW51bURlZmluaXRpb248VD4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1485,"slug":"null-schema","name":"null_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"NullDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1491,"slug":"datetime-schema","name":"datetime_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"zone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'UTC'"}],"return_type":[{"name":"DateTimeDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1501,"slug":"time-schema","name":"time_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TimeDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1507,"slug":"date-schema","name":"date_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DateDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1513,"slug":"json-schema","name":"json_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"JsonDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1519,"slug":"html-schema","name":"html_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"HTMLDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1525,"slug":"html-element-schema","name":"html_element_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"HTMLElementDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1531,"slug":"xml-schema","name":"xml_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"XMLDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1537,"slug":"xml-element-schema","name":"xml_element_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"XMLElementDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1550,"slug":"structure-schema","name":"structure_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"StructureType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"StructureDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBTdHJ1Y3R1cmVUeXBlPGFycmF5PGFycmF5LWtleSwgVD4+fFR5cGU8YXJyYXk8YXJyYXkta2V5LCBUPj4gJHR5cGUKICoKICogQHJldHVybiBTdHJ1Y3R1cmVEZWZpbml0aW9uPFQ+CiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1561,"slug":"uuid-schema","name":"uuid_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"UuidDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1567,"slug":"time-zone-schema","name":"time_zone_schema","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TimeZoneDefinition","namespace":"Flow\\ETL\\Schema\\Definition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1580,"slug":"definition-from-array","name":"definition_from_array","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"definition","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Definition","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERlZmluaXRpb24gZnJvbSBhbiBhcnJheSByZXByZXNlbnRhdGlvbi4KICoKICogQHBhcmFtIGFycmF5PGFycmF5LWtleSwgbWl4ZWQ+ICRkZWZpbml0aW9uCiAqCiAqIEByZXR1cm4gRGVmaW5pdGlvbjxtaXhlZD4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1613,"slug":"definition-from-type","name":"definition_from_type","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"ref","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Definition","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERlZmluaXRpb24gZnJvbSBhIFR5cGUuCiAqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAkdHlwZQogKgogKiBAcmV0dXJuIERlZmluaXRpb248bWl4ZWQ+CiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1666,"slug":"infer-schema","name":"infer_schema","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SchemaInferenceBuilder","namespace":"Flow\\ETL\\Schema\\Inference","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1672,"slug":"execution-context","name":"execution_context","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FlowContext","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1678,"slug":"flow-context","name":"flow_context","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"config","type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FlowContext","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1684,"slug":"config","name":"config","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Config","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1690,"slug":"config-builder","name":"config_builder","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"ConfigBuilder","namespace":"Flow\\ETL\\Config","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1696,"slug":"memory-sort","name":"memory_sort","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"MemorySortBuilder","namespace":"Flow\\ETL\\Config\\Sort","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1702,"slug":"external-sort","name":"external_sort","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"ExternalSortBuilder","namespace":"Flow\\ETL\\Config\\Sort","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1708,"slug":"hash-join","name":"hash_join","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"HashJoinBuilder","namespace":"Flow\\ETL\\Config\\Join","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1714,"slug":"hash-group-by","name":"hash_group_by","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"HashGroupByBuilder","namespace":"Flow\\ETL\\Config\\Grouping","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1720,"slug":"hash-repartition","name":"hash_repartition","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"HashRepartitionBuilder","namespace":"Flow\\ETL\\Config\\Repartition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1729,"slug":"pivot-values","name":"pivot_values","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"values","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"DeclaredPivotValues","namespace":"Flow\\ETL\\GroupBy","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERlY2xhcmVzIHRoZSBwaXZvdCBjb2x1bW5zIGEgZ3JvdXBCeSgpLT5waXZvdCgpIHByb2R1Y2VzLCBzbyB0aGUgcGxhbiBjYW4gbmFtZSB0aGVtIGJlZm9yZSBhIHJvdyBmbG93cy4KICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1739,"slug":"discover-pivot-values","name":"discover_pivot_values","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"maxValues","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"10000"}],"return_type":[{"name":"DiscoveredPivotValues","namespace":"Flow\\ETL\\GroupBy","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJlYWRzIHRoZSBwaXZvdCBjb2x1bW4gb25jZSBhdCBidWlsZCB0aW1lIGFuZCB0dXJucyB3aGF0IGl0IGZpbmRzIGludG8gZGVjbGFyZWQgdmFsdWVzLiBSZWZ1c2VzIGEKICogc291cmNlIHRoYXQgY2Fubm90IGJlIHJlYWQgdHdpY2UuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1745,"slug":"partition-by","name":"partition_by","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"entry","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"entries","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Partitioning","namespace":"Flow\\ETL\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1754,"slug":"partition-types","name":"partition_types","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"PartitionTypes","namespace":"Flow\\ETL\\Extractor\\File","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAuLi4kdHlwZXMgcGFydGl0aW9uIGNvbHVtbiBuYW1lID0+IHR5cGUsIHBhc3NlZCBhcyBuYW1lZCBhcmd1bWVudHMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1764,"slug":"overwrite","name":"overwrite","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfb3ZlcndyaXRlKCkuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1770,"slug":"save-mode-overwrite","name":"save_mode_overwrite","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1779,"slug":"ignore","name":"ignore","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfaWdub3JlKCkuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1785,"slug":"save-mode-ignore","name":"save_mode_ignore","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1794,"slug":"exception-if-exists","name":"exception_if_exists","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfZXhjZXB0aW9uX2lmX2V4aXN0cygpLgogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1800,"slug":"save-mode-exception-if-exists","name":"save_mode_exception_if_exists","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1809,"slug":"append","name":"append","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEFsaWFzIGZvciBzYXZlX21vZGVfYXBwZW5kKCkuCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1815,"slug":"save-mode-append","name":"save_mode_append","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"SaveMode","namespace":"Flow\\ETL\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1821,"slug":"print-rows","name":"print_rows","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"rows","type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"truncate","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"formatter","type":[{"name":"Formatter","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1827,"slug":"identical","name":"identical","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"left","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Identical","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1833,"slug":"equal","name":"equal","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"left","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Equal","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1839,"slug":"compare-all","name":"compare_all","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"comparison","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"comparisons","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1845,"slug":"compare-any","name":"compare_any","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"comparison","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"comparisons","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\ETL\\Join\\Comparison","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"COMPARISON"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1856,"slug":"join-on","name":"join_on","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"comparisons","type":[{"name":"Comparison","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"join_prefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"''"}],"return_type":[{"name":"Expression","namespace":"Flow\\ETL\\Join","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"joins","example":"join"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"joins","example":"join_each"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxDb21wYXJpc29ufHN0cmluZz58Q29tcGFyaXNvbiAkY29tcGFyaXNvbnMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1862,"slug":"schema-sort-by-name","name":"schema_sort_by_name","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1871,"slug":"schema-sort-by-type","name":"schema_sort_by_type","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"priorities","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[...]"},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+LCBpbnQ+ICRwcmlvcml0aWVzCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1882,"slug":"schema-sort-by-type-and-name","name":"schema_sort_by_type_and_name","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"priorities","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[...]"},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+LCBpbnQ+ICRwcmlvcml0aWVzCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1893,"slug":"schema-sort-by-metadata","name":"schema_sort_by_metadata","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"key","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Row\\SortOrder::..."}],"return_type":[{"name":"SortingStrategy","namespace":"Flow\\ETL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1903,"slug":"is-type","name":"is_type","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmd8VHlwZTxtaXhlZD4+fFR5cGU8bWl4ZWQ+ICR0eXBlCiAqIEBwYXJhbSBtaXhlZCAkdmFsdWUKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1937,"slug":"generate-random-string","name":"generate_random_string","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"32"},{"name":"generator","type":[{"name":"RandomValueGenerator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\NativePHPRandomValueGenerator::..."}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1945,"slug":"generate-random-int","name":"generate_random_int","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"start","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"-9223372036854775808"},{"name":"end","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"9223372036854775807"},{"name":"generator","type":[{"name":"RandomValueGenerator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\NativePHPRandomValueGenerator::..."}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1954,"slug":"random-string","name":"random_string","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"length","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"generator","type":[{"name":"RandomValueGenerator","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\NativePHPRandomValueGenerator::..."}],"return_type":[{"name":"RandomString","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"DATA_FRAME"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1962,"slug":"date-interval-to-milliseconds","name":"date_interval_to_milliseconds","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1979,"slug":"date-interval-to-seconds","name":"date_interval_to_seconds","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":1996,"slug":"date-interval-to-microseconds","name":"date_interval_to_microseconds","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"interval","type":[{"name":"DateInterval","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2013,"slug":"with-entry","name":"with_entry","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"function","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"WithEntry","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2019,"slug":"constraint-unique","name":"constraint_unique","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"reference","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"references","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"UniqueConstraint","namespace":"Flow\\ETL\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2025,"slug":"constraint-sorted-by","name":"constraint_sorted_by","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"column","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"SortedByConstraint","namespace":"Flow\\ETL\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2035,"slug":"analyze","name":"analyze","namespace":"Flow\\ETL\\DSL","parameters":[],"return_type":[{"name":"Analyze","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2044,"slug":"match-cases","name":"match_cases","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"cases","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"default","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MatchCases","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":true,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxNYXRjaENvbmRpdGlvbj4gJGNhc2VzCiAqLw=="},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2050,"slug":"match-condition","name":"match_condition","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"condition","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"then","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MatchCondition","namespace":"Flow\\ETL\\Function\\MatchCases","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"SCALAR_FUNCTION"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/ETL\/DSL\/functions.php","start_line_in_file":2056,"slug":"clock","name":"clock","namespace":"Flow\\ETL\\DSL","parameters":[{"name":"time_zone","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'UTC'"}],"return_type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":31,"slug":"from-floe","name":"from_floe","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"codec","type":[{"name":"Codec","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Floe\\Codec\\NoopCodec::..."},{"name":"chunk_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"65536"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FloeExtractor","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":44,"slug":"to-floe","name":"to_floe","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Floe\\Options::..."},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"FloeLoader","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKi8="},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":54,"slug":"floe-options","name":"floe_options","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"buffer_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"65536"},{"name":"codec","type":[{"name":"Codec","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Floe\\Codec\\NoopCodec::..."}],"return_type":[{"name":"Options","namespace":"Flow\\Floe","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/Floe\/DSL\/functions.php","start_line_in_file":66,"slug":"merge-floe","name":"merge_floe","namespace":"Flow\\Floe\\DSL","parameters":[{"name":"sources","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"dest","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"backend","type":[{"name":"Backend","namespace":"Flow\\ETL\\Column","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"compact","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"metadata","type":[{"name":"Metadata","namespace":"Flow\\ETL\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"void","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FLOE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE1lcmdlcyBzZXZlcmFsIEZsb2UgZmlsZXMgKHNhbWUgb3IgYXBwZW5kLWNvbXBhdGlibGUgZXZvbHZpbmcgc2NoZW1hKSBpbnRvIG9uZS4gQnl0ZS1zcGxpY2VzIGZyYW1lCiAqIHJlZ2lvbnMgYnkgZGVmYXVsdCAoTyhieXRlcyksIG5vIHJlLWVuY29kZSk7IGNvbXBhY3QgcmUtZW5jb2RlcyBhbGwgcm93cyBpbnRvIGZld2VyIHNlY3Rpb25zLgogKgogKiBAcGFyYW0gYXJyYXk8aW50LCBQYXRofHN0cmluZz4gJHNvdXJjZXMKICov"},{"repository_path":"src\/core\/etl\/src\/Flow\/Serializer\/DSL\/functions.php","start_line_in_file":18,"slug":"serialize-to-string","name":"serialize_to_string","namespace":"Flow\\Serializer\\DSL","parameters":[{"name":"serializer","type":[{"name":"Serializer","namespace":"Flow\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"rows","type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/core\/etl\/src\/Flow\/Serializer\/DSL\/functions.php","start_line_in_file":27,"slug":"unserialize-from-string","name":"unserialize_from_string","namespace":"Flow\\Serializer\\DSL","parameters":[{"name":"serializer","type":[{"name":"Serializer","namespace":"Flow\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"payload","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Rows","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CORE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-avro\/src\/Flow\/ETL\/Adapter\/Avro\/functions.php","start_line_in_file":21,"slug":"from-avro","name":"from_avro","namespace":"Flow\\ETL\\DSL\\Adapter\\Avro","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"AvroExtractor","namespace":"Flow\\ETL\\Adapter\\Avro\\FlixTech","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AVRO","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-avro\/src\/Flow\/ETL\/Adapter\/Avro\/functions.php","start_line_in_file":27,"slug":"to-avro","name":"to_avro","namespace":"Flow\\ETL\\DSL\\Adapter\\Avro","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"AvroLoader","namespace":"Flow\\ETL\\Adapter\\Avro\\FlixTech","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AVRO","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":23,"slug":"bar-chart","name":"bar_chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"label","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"datasets","type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BarChart","namespace":"Flow\\ETL\\Adapter\\ChartJS\\Chart","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":29,"slug":"line-chart","name":"line_chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"label","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"datasets","type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"LineChart","namespace":"Flow\\ETL\\Adapter\\ChartJS\\Chart","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":35,"slug":"pie-chart","name":"pie_chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"label","type":[{"name":"Reference","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"datasets","type":[{"name":"References","namespace":"Flow\\ETL\\Row","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PieChart","namespace":"Flow\\ETL\\Adapter\\ChartJS\\Chart","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":41,"slug":"to-chartjs","name":"to_chartjs","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"type","type":[{"name":"Chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ChartJSLoader","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":52,"slug":"to-chartjs-file","name":"to_chartjs_file","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"type","type":[{"name":"Chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"output","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"template","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ChartJSLoader","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDaGFydCAkdHlwZQogKiBAcGFyYW0gbnVsbHxQYXRofHN0cmluZyAkb3V0cHV0IC0gQGRlcHJlY2F0ZWQgdXNlICRsb2FkZXItPndpdGhPdXRwdXRQYXRoKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxQYXRofHN0cmluZyAkdGVtcGxhdGUgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aFRlbXBsYXRlKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-chartjs\/src\/Flow\/ETL\/Adapter\/ChartJS\/functions.php","start_line_in_file":84,"slug":"to-chartjs-var","name":"to_chartjs_var","namespace":"Flow\\ETL\\Adapter\\ChartJS","parameters":[{"name":"type","type":[{"name":"Chart","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"output","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ChartJSLoader","namespace":"Flow\\ETL\\Adapter\\ChartJS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CHART_JS","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDaGFydCAkdHlwZQogKiBAcGFyYW0gYXJyYXk8YXJyYXkta2V5LCBtaXhlZD4gJG91dHB1dCAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoT3V0cHV0VmFyKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-csv\/src\/Flow\/ETL\/Adapter\/CSV\/functions.php","start_line_in_file":35,"slug":"from-csv","name":"from_csv","namespace":"Flow\\ETL\\Adapter\\CSV","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"empty_to_null","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"separator","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"enclosure","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"escape","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"characters_read_in_line","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"10485760"},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"CSVExtractor","namespace":"Flow\\ETL\\Adapter\\CSV","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CSV","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"csv"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gYm9vbCAkZW1wdHlfdG9fbnVsbCAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRW1wdHlUb051bGwoKSBpbnN0ZWFkCiAqIEBwYXJhbSBib29sICR3aXRoX2hlYWRlciAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoSGVhZGVyKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNlcGFyYXRvciAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoU2VwYXJhdG9yKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGVuY2xvc3VyZSAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRW5jbG9zdXJlKCkgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGVzY2FwZSAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRXNjYXBlKCkgaW5zdGVhZAogKiBAcGFyYW0gaW50PDEsIG1heD4gJGNoYXJhY3RlcnNfcmVhZF9pbl9saW5lIC0gQGRlcHJlY2F0ZWQgdXNlICRsb2FkZXItPndpdGhDaGFyYWN0ZXJzUmVhZEluTGluZSgpIGluc3RlYWQKICogQHBhcmFtIG51bGx8U2NoZW1hICRzY2hlbWEgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aFNjaGVtYSgpIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-csv\/src\/Flow\/ETL\/Adapter\/CSV\/functions.php","start_line_in_file":80,"slug":"to-csv","name":"to_csv","namespace":"Flow\\ETL\\Adapter\\CSV","parameters":[{"name":"uri","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"','"},{"name":"enclosure","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\\"'"},{"name":"escape","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\\\'"},{"name":"new_line_separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\n'"},{"name":"datetime_format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d\\\\TH:i:sP'"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"CSVLoader","namespace":"Flow\\ETL\\Adapter\\CSV","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CSV","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkdXJpCiAqIEBwYXJhbSBib29sICR3aXRoX2hlYWRlciAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoSGVhZGVyKCkgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRzZXBhcmF0b3IgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aFNlcGFyYXRvcigpIGluc3RlYWQKICogQHBhcmFtIHN0cmluZyAkZW5jbG9zdXJlIC0gQGRlcHJlY2F0ZWQgdXNlICRsb2FkZXItPndpdGhFbmNsb3N1cmUoKSBpbnN0ZWFkCiAqIEBwYXJhbSBzdHJpbmcgJGVzY2FwZSAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRXNjYXBlKCkgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRuZXdfbGluZV9zZXBhcmF0b3IgLSBAZGVwcmVjYXRlZCB1c2UgJGxvYWRlci0+d2l0aE5ld0xpbmVTZXBhcmF0b3IoKSBpbnN0ZWFkCiAqIEBwYXJhbSBzdHJpbmcgJGRhdGV0aW1lX2Zvcm1hdCAtIEBkZXByZWNhdGVkIHVzZSAkbG9hZGVyLT53aXRoRGF0ZVRpbWVGb3JtYXQoKSBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-csv\/src\/Flow\/ETL\/Adapter\/CSV\/functions.php","start_line_in_file":106,"slug":"csv-detect-separator","name":"csv_detect_separator","namespace":"Flow\\ETL\\Adapter\\CSV","parameters":[{"name":"stream","type":[{"name":"SourceStream","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"lines","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"5"},{"name":"fallback","type":[{"name":"Option","namespace":"Flow\\ETL\\Adapter\\CSV\\Detector","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"Flow\\ETL\\Adapter\\CSV\\Detector\\Option::..."},{"name":"options","type":[{"name":"Options","namespace":"Flow\\ETL\\Adapter\\CSV\\Detector","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Option","namespace":"Flow\\ETL\\Adapter\\CSV\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"CSV","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBTb3VyY2VTdHJlYW0gJHN0cmVhbSAtIHZhbGlkIHJlc291cmNlIHRvIENTViBmaWxlCiAqIEBwYXJhbSBpbnQ8MSwgbWF4PiAkbGluZXMgLSBudW1iZXIgb2YgbGluZXMgdG8gcmVhZCBmcm9tIENTViBmaWxlLCBkZWZhdWx0IDUsIG1vcmUgbGluZXMgbWVhbnMgbW9yZSBhY2N1cmF0ZSBkZXRlY3Rpb24gYnV0IHNsb3dlciBkZXRlY3Rpb24KICogQHBhcmFtIG51bGx8T3B0aW9uICRmYWxsYmFjayAtIGZhbGxiYWNrIG9wdGlvbiB0byB1c2Ugd2hlbiBubyBiZXN0IG9wdGlvbiBjYW4gYmUgZGV0ZWN0ZWQsIGRlZmF1bHQgaXMgT3B0aW9uKCcsJywgJyInLCAnXFwnKQogKiBAcGFyYW0gbnVsbHxPcHRpb25zICRvcHRpb25zIC0gb3B0aW9ucyB0byB1c2UgZm9yIGRldGVjdGlvbiwgZGVmYXVsdCBpcyBPcHRpb25zOjphbGwoKQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":41,"slug":"dbal-dataframe-factory","name":"dbal_dataframe_factory","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"QueryParameter","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"DbalDataFrameFactory","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPnxDb25uZWN0aW9uICRjb25uZWN0aW9uCiAqIEBwYXJhbSBzdHJpbmcgJHF1ZXJ5CiAqIEBwYXJhbSBRdWVyeVBhcmFtZXRlciAuLi4kcGFyYW1ldGVycwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":61,"slug":"from-dbal-limit-offset","name":"from_dbal_limit_offset","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"Table","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"order_by","type":[{"name":"OrderBy","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"page_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"maximum","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DbalLimitOffsetExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDb25uZWN0aW9uICRjb25uZWN0aW9uCiAqIEBwYXJhbSBzdHJpbmd8VGFibGUgJHRhYmxlCiAqIEBwYXJhbSBhcnJheTxPcmRlckJ5PnxPcmRlckJ5ICRvcmRlcl9ieQogKiBAcGFyYW0gaW50ICRwYWdlX3NpemUgLSBiZWNvbWVzIHRoZSBleHRyYWN0b3IncyBiYXRjaCBzaXplOiByb3dzIHBlciBwYWdlCiAqIEBwYXJhbSBudWxsfGludCAkbWF4aW11bQogKgogKiBAdGhyb3dzIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":88,"slug":"from-dbal-limit-offset-qb","name":"from_dbal_limit_offset_qb","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"queryBuilder","type":[{"name":"QueryBuilder","namespace":"Doctrine\\DBAL\\Query","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"page_size","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"maximum","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"DbalLimitOffsetExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBDb25uZWN0aW9uICRjb25uZWN0aW9uCiAqIEBwYXJhbSBpbnQgJHBhZ2Vfc2l6ZSAtIGJlY29tZXMgdGhlIGV4dHJhY3RvcidzIGJhdGNoIHNpemU6IHJvd3MgcGVyIHBhZ2UKICogQHBhcmFtIG51bGx8aW50ICRtYXhpbXVtIC0gbWF4aW11bSBjYW4gYWxzbyBiZSB0YWtlbiBmcm9tIGEgcXVlcnkgYnVpbGRlciwgJG1heGltdW0gaG93ZXZlciBpcyB1c2VkIHJlZ2FyZGxlc3Mgb2YgdGhlIHF1ZXJ5IGJ1aWxkZXIgaWYgaXQncyBzZXQKICogQHBhcmFtIGludCAkb2Zmc2V0IC0gb2Zmc2V0IGNhbiBhbHNvIGJlIHRha2VuIGZyb20gYSBxdWVyeSBidWlsZGVyLCAkb2Zmc2V0IGhvd2V2ZXIgaXMgdXNlZCByZWdhcmRsZXNzIG9mIHRoZSBxdWVyeSBidWlsZGVyIGlmIGl0J3Mgc2V0IHRvIG5vbiAwIHZhbHVlCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":107,"slug":"from-dbal-key-set-qb","name":"from_dbal_key_set_qb","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"queryBuilder","type":[{"name":"QueryBuilder","namespace":"Doctrine\\DBAL\\Query","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key_set","type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DbalKeySetExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":117,"slug":"from-dbal-queries","name":"from_dbal_queries","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters_set","type":[{"name":"ParametersSet","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBudWxsfFBhcmFtZXRlcnNTZXQgJHBhcmFtZXRlcnNfc2V0IC0gZWFjaCBvbmUgcGFyYW1ldGVycyBhcnJheSB3aWxsIGJlIGV2YWx1YXRlZCBhcyBuZXcgcXVlcnkKICogQHBhcmFtIGFycmF5PGludDwwLCBtYXg+fHN0cmluZywgRGJhbEFycmF5VHlwZXxEYmFsUGFyYW1ldGVyVHlwZXxEYmFsVHlwZXxzdHJpbmc+ICR0eXBlcwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":143,"slug":"dbal-from-queries","name":"dbal_from_queries","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters_set","type":[{"name":"ParametersSet","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBkZXByZWNhdGVkIHVzZSBmcm9tX2RiYWxfcXVlcmllcygpIGluc3RlYWQKICoKICogQHBhcmFtIG51bGx8UGFyYW1ldGVyc1NldCAkcGFyYW1ldGVyc19zZXQgLSBlYWNoIG9uZSBwYXJhbWV0ZXJzIGFycmF5IHdpbGwgYmUgZXZhbHVhdGVkIGFzIG5ldyBxdWVyeQogKiBAcGFyYW0gYXJyYXk8aW50PDAsIG1heD58c3RyaW5nLCBEYmFsQXJyYXlUeXBlfERiYWxQYXJhbWV0ZXJUeXBlfERiYWxUeXBlfHN0cmluZz4gJHR5cGVzCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":157,"slug":"from-dbal-query","name":"from_dbal_query","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPnxsaXN0PG1peGVkPiAkcGFyYW1ldGVycyAtIEBkZXByZWNhdGVkIHVzZSBEYmFsUXVlcnlFeHRyYWN0b3I6OndpdGhQYXJhbWV0ZXJzKCkgaW5zdGVhZAogKiBAcGFyYW0gYXJyYXk8aW50PDAsIG1heD58c3RyaW5nLCBEYmFsQXJyYXlUeXBlfERiYWxQYXJhbWV0ZXJUeXBlfERiYWxUeXBlfHN0cmluZz4gJHR5cGVzIC0gQGRlcHJlY2F0ZWQgdXNlIERiYWxRdWVyeUV4dHJhY3Rvcjo6d2l0aFR5cGVzKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":173,"slug":"dbal-from-query","name":"dbal_from_query","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"types","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"DbalQueryExtractor","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBkZXByZWNhdGVkIHVzZSBmcm9tX2RiYWxfcXVlcnkoKSBpbnN0ZWFkCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPnxsaXN0PG1peGVkPiAkcGFyYW1ldGVycyAtIEBkZXByZWNhdGVkIHVzZSBEYmFsUXVlcnlFeHRyYWN0b3I6OndpdGhQYXJhbWV0ZXJzKCkgaW5zdGVhZAogKiBAcGFyYW0gYXJyYXk8aW50PDAsIG1heD58c3RyaW5nLCBEYmFsQXJyYXlUeXBlfERiYWxQYXJhbWV0ZXJUeXBlfERiYWxUeXBlfHN0cmluZz4gJHR5cGVzIC0gQGRlcHJlY2F0ZWQgdXNlIERiYWxRdWVyeUV4dHJhY3Rvcjo6d2l0aFR5cGVzKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":199,"slug":"to-dbal-table-insert","name":"to_dbal_table_insert","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"InsertOptions","namespace":"Flow\\Doctrine\\Bulk","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DbalLoader","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"dbal","option":"upsert"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEluc2VydCBuZXcgcm93cyBpbnRvIGEgZGF0YWJhc2UgdGFibGUuCiAqIEluc2VydCBjYW4gYWxzbyBiZSB1c2VkIGFzIGFuIHVwc2VydCB3aXRoIHRoZSBoZWxwIG9mIEluc2VydE9wdGlvbnMuCiAqIEluc2VydE9wdGlvbnMgYXJlIHBsYXRmb3JtIHNwZWNpZmljLCBzbyBwbGVhc2UgY2hvb3NlIHRoZSByaWdodCBvbmUgZm9yIHlvdXIgZGF0YWJhc2UuCiAqCiAqICAtIE15U1FMSW5zZXJ0T3B0aW9ucwogKiAgLSBQb3N0Z3JlU1FMSW5zZXJ0T3B0aW9ucwogKiAgLSBTcWxpdGVJbnNlcnRPcHRpb25zCiAqCiAqIEluIG9yZGVyIHRvIGNvbnRyb2wgdGhlIHNpemUgb2YgdGhlIHNpbmdsZSBpbnNlcnQsIHVzZSBEYXRhRnJhbWU6OmNodW5rU2l6ZSgpIG1ldGhvZCBqdXN0IGJlZm9yZSBjYWxsaW5nIERhdGFGcmFtZTo6bG9hZCgpLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBtaXhlZD58Q29ubmVjdGlvbiAkY29ubmVjdGlvbgogKgogKiBAdGhyb3dzIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":216,"slug":"to-dbal-table-update","name":"to_dbal_table_update","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"UpdateOptions","namespace":"Flow\\Doctrine\\Bulk","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"DbalLoader","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqICBVcGRhdGUgZXhpc3Rpbmcgcm93cyBpbiBkYXRhYmFzZS4KICoKICogIEluIG9yZGVyIHRvIGNvbnRyb2wgdGhlIHNpemUgb2YgdGhlIHNpbmdsZSByZXF1ZXN0LCB1c2UgRGF0YUZyYW1lOjpjaHVua1NpemUoKSBtZXRob2QganVzdCBiZWZvcmUgY2FsbGluZyBEYXRhRnJhbWU6OmxvYWQoKS4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fENvbm5lY3Rpb24gJGNvbm5lY3Rpb24KICoKICogQHRocm93cyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24KICov"},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":235,"slug":"to-dbal-table-delete","name":"to_dbal_table_delete","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DbalLoader","namespace":"Flow\\ETL\\Adapter\\Doctrine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERlbGV0ZSByb3dzIGZyb20gZGF0YWJhc2UgdGFibGUgYmFzZWQgb24gdGhlIHByb3ZpZGVkIGRhdGEuCiAqCiAqIEluIG9yZGVyIHRvIGNvbnRyb2wgdGhlIHNpemUgb2YgdGhlIHNpbmdsZSByZXF1ZXN0LCB1c2UgRGF0YUZyYW1lOjpjaHVua1NpemUoKSBtZXRob2QganVzdCBiZWZvcmUgY2FsbGluZyBEYXRhRnJhbWU6OmxvYWQoKS4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fENvbm5lY3Rpb24gJGNvbm5lY3Rpb24KICoKICogQHRocm93cyBJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24KICov"},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":250,"slug":"to-dbal-schema-table","name":"to_dbal_schema_table","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table_options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"types_map","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Table","namespace":"Doctrine\\DBAL\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnRzIGEgRmxvd1xFVExcU2NoZW1hIHRvIGEgRG9jdHJpbmVcREJBTFxTY2hlbWFcVGFibGUuCiAqCiAqIEBwYXJhbSBTY2hlbWEgJHNjaGVtYQogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBtaXhlZD4gJHRhYmxlX29wdGlvbnMKICogQHBhcmFtIGFycmF5PGNsYXNzLXN0cmluZzxcRmxvd1xUeXBlc1xUeXBlPG1peGVkPj4sIGNsYXNzLXN0cmluZzxcRG9jdHJpbmVcREJBTFxUeXBlc1xUeXBlPj4gJHR5cGVzX21hcAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":267,"slug":"table-schema-to-flow-schema","name":"table_schema_to_flow_schema","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"table","type":[{"name":"Table","namespace":"Doctrine\\DBAL\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"types_map","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnRzIGEgRG9jdHJpbmVcREJBTFxTY2hlbWFcVGFibGUgdG8gYSBGbG93XEVUTFxTY2hlbWEuCiAqCiAqIEBwYXJhbSBhcnJheTxjbGFzcy1zdHJpbmc8XEZsb3dcVHlwZXNcVHlwZTxtaXhlZD4+LCBjbGFzcy1zdHJpbmc8XERvY3RyaW5lXERCQUxcVHlwZXNcVHlwZT4+ICR0eXBlc19tYXAKICoKICogQHJldHVybiBTY2hlbWEKICov"},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":278,"slug":"postgresql-insert-options","name":"postgresql_insert_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"skip_conflicts","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"constraint","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"conflict_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSQLInsertOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"dbal","option":"upsert"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICRjb25mbGljdF9jb2x1bW5zCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":291,"slug":"mysql-insert-options","name":"mysql_insert_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"skip_conflicts","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"upsert","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"MySQLInsertOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":304,"slug":"sqlite-insert-options","name":"sqlite_insert_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"skip_conflicts","type":[{"name":"bool","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"conflict_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"SqliteInsertOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICRjb25mbGljdF9jb2x1bW5zCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":317,"slug":"postgresql-update-options","name":"postgresql_update_options","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"primary_key_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"update_columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSQLUpdateOptions","namespace":"Flow\\Doctrine\\Bulk\\Dialect","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICRwcmltYXJ5X2tleV9jb2x1bW5zCiAqIEBwYXJhbSBhcnJheTxzdHJpbmc+ICR1cGRhdGVfY29sdW1ucwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":338,"slug":"to-dbal-transaction","name":"to_dbal_transaction","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"connection","type":[{"name":"Connection","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sinks","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Transactional","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyaXRlIGV2ZXJ5IHNpbmsgd2l0aGluIGRhdGFiYXNlIHRyYW5zYWN0aW9ucy4KICogRWFjaCBiYXRjaCBvZiByb3dzIGlzIHdyaXR0ZW4gaW4gaXRzIG93biB0cmFuc2FjdGlvbjsgcm93cyBhIHNpbmsncyBUcmFuc2Zvcm1hdGlvbiBkZWxpdmVycyB3aGVuCiAqIHRoZSBydW4gZW5kcyAoYmxvY2tpbmcgb3BlcmF0aW9ucyBkcmFpbiB0aGVyZSkgYXJlIGNvbW1pdHRlZCBpbiBvbmUgZmluYWwgdHJhbnNhY3Rpb24uCiAqIElmIGFueSBzaW5rIGZhaWxzLCB0aGUgb3BlbiB0cmFuc2FjdGlvbiBpcyByb2xsZWQgYmFjay4KICogQSBwbGFpbiBMb2FkZXIgY2hpbGQgaXMgYSBiYXJlIHNpbmsgcm9vdDsgYSB0b190cmFuc2Zvcm1hdGlvbiguLi4pIGNoaWxkIGRlbGl2ZXJzIGluc2lkZSB0aGUgc2FtZQogKiB0cmFuc2FjdGlvbi4gRXZlcnkgY2hpbGQncyBsb2FkZXIgbXVzdCB1c2UgdGhlIHNhbWUgY29ubmVjdGlvbiBhcyB0aGUgdHJhbnNhY3Rpb246IHBhc3Mgb25lIGxpdmUKICogQ29ubmVjdGlvbiB0byBib3RoIC0gYSBsb2FkZXIgYnVpbHQgZnJvbSBhcnJheSBwYXJhbXMgb3BlbnMgaXRzIG93biBjb25uZWN0aW9uIGFuZCBlc2NhcGVzIHRoZQogKiB0cmFuc2FjdGlvbi4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fENvbm5lY3Rpb24gJGNvbm5lY3Rpb24KICogQHBhcmFtIExvYWRlcnxTaW5rIC4uLiRzaW5rcyAtIHNpbmtzIHdyaXR0ZW4gd2l0aGluIHRoZSB0cmFuc2FjdGlvbgogKgogKiBAdGhyb3dzIEludmFsaWRBcmd1bWVudEV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":347,"slug":"pagination-key-asc","name":"pagination_key_asc","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ParameterType","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Doctrine\\DBAL\\Types","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Doctrine\\DBAL\\ParameterType::..."}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":353,"slug":"pagination-key-desc","name":"pagination_key_desc","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ParameterType","namespace":"Doctrine\\DBAL","is_nullable":false,"is_variadic":false},{"name":"Type","namespace":"Doctrine\\DBAL\\Types","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Doctrine\\DBAL\\ParameterType::..."}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-doctrine\/src\/Flow\/ETL\/Adapter\/Doctrine\/functions.php","start_line_in_file":359,"slug":"pagination-key-set","name":"pagination_key_set","namespace":"Flow\\ETL\\Adapter\\Doctrine","parameters":[{"name":"keys","type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\Doctrine\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"DOCTRINE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-excel\/src\/Flow\/ETL\/Adapter\/Excel\/DSL\/functions.php","start_line_in_file":22,"slug":"from-excel","name":"from_excel","namespace":"Flow\\ETL\\Adapter\\Excel\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ExcelExtractor","namespace":"Flow\\ETL\\Adapter\\Excel","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"EXCEL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-excel\/src\/Flow\/ETL\/Adapter\/Excel\/DSL\/functions.php","start_line_in_file":28,"slug":"to-excel","name":"to_excel","namespace":"Flow\\ETL\\Adapter\\Excel\\DSL","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ExcelLoader","namespace":"Flow\\ETL\\Adapter\\Excel","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"EXCEL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-excel\/src\/Flow\/ETL\/Adapter\/Excel\/DSL\/functions.php","start_line_in_file":34,"slug":"is-valid-excel-sheet-name","name":"is_valid_excel_sheet_name","namespace":"Flow\\ETL\\Adapter\\Excel\\DSL","parameters":[{"name":"sheet_name","type":[{"name":"ScalarFunction","namespace":"Flow\\ETL\\Function","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"IsValidExcelSheetName","namespace":"Flow\\ETL\\Adapter\\Excel\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"EXCEL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-google-sheet\/src\/Flow\/ETL\/Adapter\/GoogleSheet\/functions.php","start_line_in_file":22,"slug":"from-google-sheet","name":"from_google_sheet","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","parameters":[{"name":"auth_config","type":[{"name":"Sheets","namespace":"Google\\Service","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"spreadsheet_id","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sheet_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"rows_per_page","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"GoogleSheetExtractor","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"GOOGLE_SHEET","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheXt0eXBlOiBzdHJpbmcsIHByb2plY3RfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXlfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXk6IHN0cmluZywgY2xpZW50X2VtYWlsOiBzdHJpbmcsIGNsaWVudF9pZDogc3RyaW5nLCBhdXRoX3VyaTogc3RyaW5nLCB0b2tlbl91cmk6IHN0cmluZywgYXV0aF9wcm92aWRlcl94NTA5X2NlcnRfdXJsOiBzdHJpbmcsIGNsaWVudF94NTA5X2NlcnRfdXJsOiBzdHJpbmd9fFNoZWV0cyAkYXV0aF9jb25maWcKICogQHBhcmFtIHN0cmluZyAkc3ByZWFkc2hlZXRfaWQKICogQHBhcmFtIHN0cmluZyAkc2hlZXRfbmFtZQogKiBAcGFyYW0gYm9vbCAkd2l0aF9oZWFkZXIgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aEhlYWRlciBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gaW50ICRyb3dzX3Blcl9wYWdlIC0gaG93IG1hbnkgcm93cyBwZXIgcGFnZSB0byBmZXRjaCBmcm9tIEdvb2dsZSBTaGVldHMgQVBJIC0gQGRlcHJlY2F0ZWQgdXNlIHdpdGhSb3dzUGVyUGFnZSBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gYXJyYXl7ZGF0ZVRpbWVSZW5kZXJPcHRpb24\/OiBzdHJpbmcsIG1ham9yRGltZW5zaW9uPzogc3RyaW5nLCB2YWx1ZVJlbmRlck9wdGlvbj86IHN0cmluZ30gJG9wdGlvbnMgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aE9wdGlvbnMgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-google-sheet\/src\/Flow\/ETL\/Adapter\/GoogleSheet\/functions.php","start_line_in_file":56,"slug":"from-google-sheet-columns","name":"from_google_sheet_columns","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","parameters":[{"name":"auth_config","type":[{"name":"Sheets","namespace":"Google\\Service","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"spreadsheet_id","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sheet_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start_range_column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end_range_column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"with_header","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"rows_per_page","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1000"},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"GoogleSheetExtractor","namespace":"Flow\\ETL\\Adapter\\GoogleSheet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"GOOGLE_SHEET","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheXt0eXBlOiBzdHJpbmcsIHByb2plY3RfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXlfaWQ6IHN0cmluZywgcHJpdmF0ZV9rZXk6IHN0cmluZywgY2xpZW50X2VtYWlsOiBzdHJpbmcsIGNsaWVudF9pZDogc3RyaW5nLCBhdXRoX3VyaTogc3RyaW5nLCB0b2tlbl91cmk6IHN0cmluZywgYXV0aF9wcm92aWRlcl94NTA5X2NlcnRfdXJsOiBzdHJpbmcsIGNsaWVudF94NTA5X2NlcnRfdXJsOiBzdHJpbmd9fFNoZWV0cyAkYXV0aF9jb25maWcKICogQHBhcmFtIHN0cmluZyAkc3ByZWFkc2hlZXRfaWQKICogQHBhcmFtIHN0cmluZyAkc2hlZXRfbmFtZQogKiBAcGFyYW0gc3RyaW5nICRzdGFydF9yYW5nZV9jb2x1bW4KICogQHBhcmFtIHN0cmluZyAkZW5kX3JhbmdlX2NvbHVtbgogKiBAcGFyYW0gYm9vbCAkd2l0aF9oZWFkZXIgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aEhlYWRlciBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gaW50ICRyb3dzX3Blcl9wYWdlIC0gaG93IG1hbnkgcm93cyBwZXIgcGFnZSB0byBmZXRjaCBmcm9tIEdvb2dsZSBTaGVldHMgQVBJLCBkZWZhdWx0IDEwMDAgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aFJvd3NQZXJQYWdlIG1ldGhvZCBpbnN0ZWFkCiAqIEBwYXJhbSBhcnJheXtkYXRlVGltZVJlbmRlck9wdGlvbj86IHN0cmluZywgbWFqb3JEaW1lbnNpb24\/OiBzdHJpbmcsIHZhbHVlUmVuZGVyT3B0aW9uPzogc3RyaW5nfSAkb3B0aW9ucyAtIEBkZXByZWNhdGVkIHVzZSB3aXRoT3B0aW9ucyBtZXRob2QgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":35,"slug":"from-dynamic-http-requests","name":"from_dynamic_http_requests","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"requestFactory","type":[{"name":"NextRequestFactory","namespace":"Flow\\ETL\\Adapter\\Http\\DynamicExtractor","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PsrHttpClientDynamicExtractor","namespace":"Flow\\ETL\\Adapter\\Http","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":53,"slug":"from-static-http-requests","name":"from_static_http_requests","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"requests","type":[{"name":"iterable","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PsrHttpClientStaticExtractor","namespace":"Flow\\ETL\\Adapter\\Http","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBpdGVyYWJsZTxSZXF1ZXN0SW50ZXJmYWNlPiAkcmVxdWVzdHMKICov"},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":68,"slug":"from-http-paginated","name":"from_http_paginated","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"request","type":[{"name":"RequestInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"paginator","type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PsrHttpClientPaginatedExtractor","namespace":"Flow\\ETL\\Adapter\\Http","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":84,"slug":"http-pagination-page-number","name":"http_pagination_page_number","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"inject","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start_page","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"page_size","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"size_option","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"inject_on_first_request","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"records_path","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":104,"slug":"http-pagination-offset","name":"http_pagination_offset","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"offset_option","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit_option","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start_offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"total_path","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"inject_on_first_request","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":124,"slug":"http-pagination-cursor","name":"http_pagination_cursor","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"cursor_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"inject","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":140,"slug":"http-pagination-next-url","name":"http_pagination_next_url","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":155,"slug":"http-pagination-link-header","name":"http_pagination_link_header","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"rel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'next'"},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":164,"slug":"http-pagination-last-record-cursor","name":"http_pagination_last_record_cursor","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"record_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"inject","type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stop_on_client_error","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"stop_when","type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Paginator","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":180,"slug":"http-request-option-query","name":"http_request_option_query","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":186,"slug":"http-request-option-header","name":"http_request_option_header","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":192,"slug":"http-request-option-body","name":"http_request_option_body","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stream_factory","type":[{"name":"StreamFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":198,"slug":"http-request-option-uri","name":"http_request_option_uri","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[],"return_type":[{"name":"RequestOption","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":204,"slug":"http-stop-when-path-missing","name":"http_stop_when_path_missing","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":210,"slug":"http-stop-when-empty-path","name":"http_stop_when_empty_path","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":216,"slug":"http-stop-when-flag-false","name":"http_stop_when_flag_false","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":222,"slug":"http-stop-when-flag-true","name":"http_stop_when_flag_true","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":228,"slug":"http-stop-when-total-reached","name":"http_stop_when_total_reached","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"total_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":234,"slug":"http-stop-when-max-pages","name":"http_stop_when_max_pages","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"pages","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-http\/src\/Flow\/ETL\/Adapter\/Http\/DSL\/functions.php","start_line_in_file":240,"slug":"http-stop-when-max-results","name":"http_stop_when_max_results","namespace":"Flow\\ETL\\Adapter\\Http","parameters":[{"name":"count","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StopWhen","namespace":"Flow\\ETL\\Adapter\\Http\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"HTTP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":32,"slug":"from-json","name":"from_json","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pointer","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonExtractor","namespace":"Flow\\ETL\\Adapter\\JSON\\JSONMachine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"json"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aCAtIHN0cmluZyBpcyBpbnRlcm5hbGx5IHR1cm5lZCBpbnRvIHN0cmVhbQogKiBAcGFyYW0gP3N0cmluZyAkcG9pbnRlciAtIGlmIHlvdSB3YW50IHRvIGl0ZXJhdGUgb25seSByZXN1bHRzIG9mIGEgc3VidHJlZSwgdXNlIGEgcG9pbnRlciwgcmVhZCBtb3JlIGF0IGh0dHBzOi8vZ2l0aHViLmNvbS9oYWxheGEvanNvbi1tYWNoaW5lI3BhcnNpbmctYS1zdWJ0cmVlIC0gQGRlcHJlY2F0ZSB1c2Ugd2l0aFBvaW50ZXIgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIG51bGx8U2NoZW1hICRzY2hlbWEgLSBlbmZvcmNlIHNjaGVtYSBvbiB0aGUgZXh0cmFjdGVkIGRhdGEgLSBAZGVwcmVjYXRlIHVzZSB3aXRoU2NoZW1hIG1ldGhvZCBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":58,"slug":"from-json-lines","name":"from_json_lines","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonExtractor","namespace":"Flow\\ETL\\Adapter\\JSON\\JSONMachine","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"jsonl"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFVzZWQgdG8gcmVhZCBmcm9tIGEgSlNPTiBsaW5lcyBodHRwczovL2pzb25saW5lcy5vcmcvIGZvcm1hdHRlZCBmaWxlLgogKgogKiBAcGFyYW0gUGF0aHxzdHJpbmcgJHBhdGggLSBzdHJpbmcgaXMgaW50ZXJuYWxseSB0dXJuZWQgaW50byBzdHJlYW0KICov"},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":72,"slug":"to-json","name":"to_json","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"flags","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"4194304"},{"name":"date_time_format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d\\\\TH:i:sP'"},{"name":"put_rows_in_new_lines","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonLoader","namespace":"Flow\\ETL\\Adapter\\JSON","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gaW50ICRmbGFncyAtIFBIUCBKU09OIEZsYWdzIC0gQGRlcHJlY2F0ZSB1c2Ugd2l0aEZsYWdzIG1ldGhvZCBpbnN0ZWFkCiAqIEBwYXJhbSBzdHJpbmcgJGRhdGVfdGltZV9mb3JtYXQgLSBmb3JtYXQgZm9yIERhdGVUaW1lSW50ZXJmYWNlOjpmb3JtYXQoKSAtIEBkZXByZWNhdGUgdXNlIHdpdGhEYXRlVGltZUZvcm1hdCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gYm9vbCAkcHV0X3Jvd3NfaW5fbmV3X2xpbmVzIC0gaWYgeW91IHdhbnQgdG8gcHV0IGVhY2ggcm93IGluIGEgbmV3IGxpbmUgLSBAZGVwcmVjYXRlIHVzZSB3aXRoUm93c0luTmV3TGluZXMgbWV0aG9kIGluc3RlYWQKICoKICogQHJldHVybiBKc29uTG9hZGVyCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":93,"slug":"to-json-lines","name":"to_json_lines","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"JsonLoader","namespace":"Flow\\ETL\\Adapter\\JSON","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFVzZWQgdG8gd3JpdGUgdG8gYSBKU09OIGxpbmVzIGh0dHBzOi8vanNvbmxpbmVzLm9yZy8gZm9ybWF0dGVkIGZpbGUuCiAqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKgogKiBAcmV0dXJuIEpzb25Mb2FkZXIKICov"},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":107,"slug":"schema-from-json-schema","name":"schema_from_json_schema","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"json_schema","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"request_factory","type":[{"name":"RequestFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBKU09OIFNjaGVtYSAoaHR0cHM6Ly9qc29uLXNjaGVtYS5vcmcpIGRvY3VtZW50IGludG8gYSBGbG93IFNjaGVtYS4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbWl4ZWQ+fFBhdGh8c3RyaW5nICRqc29uX3NjaGVtYSAtIGRlY29kZWQgZG9jdW1lbnQsIHJhdyBKU09OIGRvY3VtZW50IG9yIGEgcGF0aCB0byBhIHNjaGVtYSBmaWxlCiAqIEBwYXJhbSBudWxsfENsaWVudEludGVyZmFjZSAkY2xpZW50IC0gUFNSLTE4IGh0dHAgY2xpZW50LCByZXF1aXJlZCB0byByZXNvbHZlIHJlbW90ZSBodHRwKHMpIHJlZmVyZW5jZXMKICogQHBhcmFtIG51bGx8UmVxdWVzdEZhY3RvcnlJbnRlcmZhY2UgJHJlcXVlc3RfZmFjdG9yeSAtIFBTUi0xNyByZXF1ZXN0IGZhY3RvcnksIHJlcXVpcmVkIHRvIHJlc29sdmUgcmVtb3RlIGh0dHAocykgcmVmZXJlbmNlcwogKiBAcGFyYW0gRmlsZXN5c3RlbSAkZmlsZXN5c3RlbSAtIGZpbGVzeXN0ZW0gdXNlZCB0byByZWFkIGxvY2FsIHNjaGVtYSByZWZlcmVuY2VzCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-json\/src\/Flow\/ETL\/Adapter\/JSON\/functions.php","start_line_in_file":122,"slug":"schema-to-json-schema","name":"schema_to_json_schema","namespace":"Flow\\ETL\\Adapter\\JSON","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"JSON","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBGbG93IFNjaGVtYSBpbnRvIGEgSlNPTiBTY2hlbWEgKGh0dHBzOi8vanNvbi1zY2hlbWEub3JnLCBkcmFmdCAyMDIwLTEyKSBkb2N1bWVudC4KICoKICogQHJldHVybiBhcnJheTxzdHJpbmcsIG1peGVkPgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":36,"slug":"from-parquet","name":"from_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Parquet","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Parquet\\Options::..."},{"name":"byte_order","type":[{"name":"ByteOrder","namespace":"Flow\\Parquet\\Binary","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Parquet\\Binary\\ByteOrder::..."},{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"engine","type":[{"name":"ParquetEngine","namespace":"Flow\\Parquet","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ParquetExtractor","namespace":"Flow\\ETL\\Adapter\\Parquet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"parquet"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gYXJyYXk8c3RyaW5nPiAkY29sdW1ucyAtIGxpc3Qgb2YgY29sdW1ucyB0byByZWFkIGZyb20gcGFycXVldCBmaWxlIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoQ29sdW1uc2AgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIE9wdGlvbnMgJG9wdGlvbnMgLSBAZGVwcmVjYXRlZCB1c2UgYHdpdGhPcHRpb25zYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gQnl0ZU9yZGVyICRieXRlX29yZGVyIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoQnl0ZU9yZGVyYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxpbnQgJG9mZnNldCAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aE9mZnNldGAgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":69,"slug":"to-parquet","name":"to_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Parquet","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"compressions","type":[{"name":"Compressions","namespace":"Flow\\Parquet\\ParquetFile","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Parquet\\ParquetFile\\Compressions::..."},{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"engine","type":[{"name":"ParquetEngine","namespace":"Flow\\Parquet","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"ParquetLoader","namespace":"Flow\\ETL\\Adapter\\Parquet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"LOADER"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"writing","example":"parquet"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gbnVsbHxPcHRpb25zICRvcHRpb25zIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoT3B0aW9uc2AgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIENvbXByZXNzaW9ucyAkY29tcHJlc3Npb25zIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoQ29tcHJlc3Npb25zYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gbnVsbHxTY2hlbWEgJHNjaGVtYSAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aFNjaGVtYWAgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":100,"slug":"array-to-generator","name":"array_to_generator","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Generator","namespace":"","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBhcnJheTxUPiAkZGF0YQogKgogKiBAcmV0dXJuIFxHZW5lcmF0b3I8VD4KICov"},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":111,"slug":"empty-generator","name":"empty_generator","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[],"return_type":[{"name":"Generator","namespace":"","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBkZXByZWNhdGVkIHVzZSBGbG93XFBhcnF1ZXRcZW1wdHlfZ2VuZXJhdG9yKCkgaW5zdGVhZAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":117,"slug":"schema-to-parquet","name":"schema_to_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\Parquet\\ParquetFile","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-parquet\/src\/Flow\/ETL\/Adapter\/Parquet\/functions.php","start_line_in_file":123,"slug":"schema-from-parquet","name":"schema_from_parquet","namespace":"Flow\\ETL\\Adapter\\Parquet","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\Parquet\\ParquetFile","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":39,"slug":"from-pgsql-cursor","name":"from_pgsql_cursor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSqlCursorExtractor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgY3Vyc29yIGV4dHJhY3RvciB1c2luZyBzZXJ2ZXItc2lkZSBjdXJzb3JzIGZvciBtZW1vcnktZWZmaWNpZW50IGV4dHJhY3Rpb24uCiAqCiAqIFVzZXMgREVDTEFSRSBDVVJTT1IgKyBGRVRDSCB0byBzdHJlYW0gZGF0YSB3aXRob3V0IGxvYWRpbmcgZW50aXJlIHJlc3VsdCBzZXQgaW50byBtZW1vcnkuCiAqIFRoaXMgaXMgdGhlIG9ubHkgd2F5IHRvIGFjaGlldmUgdHJ1ZSBsb3cgbWVtb3J5IGV4dHJhY3Rpb24gd2l0aCBQSFAncyBleHQtcGdzcWwuCiAqCiAqIE5vdGU6IFJlcXVpcmVzIGEgdHJhbnNhY3Rpb24gY29udGV4dCAoYXV0by1zdGFydGVkIGlmIG5vdCBpbiBvbmUpLgogKgogKiBAcGFyYW0gQ2xpZW50ICRjbGllbnQgUG9zdGdyZVNRTCBjbGllbnQKICogQHBhcmFtIFNxbHxzdHJpbmcgJHF1ZXJ5IFNRTCBxdWVyeSB0byBleGVjdXRlICh3cmFwcGVkIGluIERFQ0xBUkUgQ1VSU09SKQogKiBAcGFyYW0gbGlzdDxtaXhlZD4gJHBhcmFtZXRlcnMgVmFsdWVzIGJvdW5kIGJ5IHBvc2l0aW9uIHRvICQxLCAkMiwgLi4uIHBsYWNlaG9sZGVyczsgd3JhcCB3aXRoIHtAc2VlIFxGbG93XFBvc3RncmVTcWxcRFNMXHR5cGVkKCl9IHRvIGZvcmNlIGEgc3BlY2lmaWMgUG9zdGdyZVNRTCB0eXBlCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":55,"slug":"from-pgsql-limit-offset","name":"from_pgsql_limit_offset","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSqlLimitOffsetExtractor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgZXh0cmFjdG9yIHVzaW5nIExJTUlUL09GRlNFVCBwYWdpbmF0aW9uLgogKgogKiBTdWl0YWJsZSBmb3Igc21hbGxlciBkYXRhc2V0cy4gRm9yIGxhcmdlIGRhdGFzZXRzLCBjb25zaWRlciB1c2luZyBrZXlzZXQgcGFnaW5hdGlvbgogKiAoZnJvbV9wZ3NxbF9rZXlfc2V0KSB3aGljaCBpcyBtb3JlIGVmZmljaWVudC4KICoKICogQHBhcmFtIENsaWVudCAkY2xpZW50IFBvc3RncmVTUUwgY2xpZW50CiAqIEBwYXJhbSBTcWx8c3RyaW5nICRxdWVyeSBTUUwgcXVlcnkgdG8gZXhlY3V0ZSAobXVzdCBoYXZlIE9SREVSIEJZIGNsYXVzZSkKICogQHBhcmFtIGxpc3Q8bWl4ZWQ+ICRwYXJhbWV0ZXJzIFZhbHVlcyBib3VuZCBieSBwb3NpdGlvbiB0byAkMSwgJDIsIC4uLiBwbGFjZWhvbGRlcnM7IHdyYXAgd2l0aCB7QHNlZSBcRmxvd1xQb3N0Z3JlU3FsXERTTFx0eXBlZCgpfSB0byBmb3JjZSBhIHNwZWNpZmljIFBvc3RncmVTUUwgdHlwZQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":75,"slug":"from-pgsql-key-set","name":"from_pgsql_key_set","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keySet","type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parameters","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"PostgreSqlKeySetExtractor","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgZXh0cmFjdG9yIHVzaW5nIGtleXNldCAoY3Vyc29yLWJhc2VkKSBwYWdpbmF0aW9uLgogKgogKiBNb3JlIGVmZmljaWVudCB0aGFuIExJTUlUL09GRlNFVCBmb3IgbGFyZ2UgZGF0YXNldHMgLSB1c2VzIGluZGV4ZWQgV0hFUkUgY29uZGl0aW9ucwogKiBpbnN0ZWFkIG9mIHNraXBwaW5nIHJvd3MuCiAqCiAqIEBwYXJhbSBDbGllbnQgJGNsaWVudCBQb3N0Z3JlU1FMIGNsaWVudAogKiBAcGFyYW0gU3FsfHN0cmluZyAkcXVlcnkgU1FMIHF1ZXJ5IHRvIGV4ZWN1dGUgKE9SREVSIEJZIG9wdGlvbmFsOyB3aGVuIHByZXNlbnQgaXQgbXVzdCBlcXVhbCB0aGUga2V5czsgbm8gTElNSVQvT0ZGU0VUOyBrZXlzIGluZGV4ZWQsIG5vbi1udWxsLCB1bmlxdWUpCiAqIEBwYXJhbSBLZXlTZXQgJGtleVNldCBDb2x1bW5zIHRvIHVzZSBmb3Iga2V5c2V0IHBhZ2luYXRpb24KICogQHBhcmFtIGxpc3Q8bWl4ZWQ+ICRwYXJhbWV0ZXJzIFZhbHVlcyBib3VuZCBieSBwb3NpdGlvbiB0byAkMSwgJDIsIC4uLiBwbGFjZWhvbGRlcnM7IHdyYXAgd2l0aCB7QHNlZSBcRmxvd1xQb3N0Z3JlU3FsXERTTFx0eXBlZCgpfSB0byBmb3JjZSBhIHNwZWNpZmljIFBvc3RncmVTUUwgdHlwZQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":85,"slug":"pgsql-pagination-key-asc","name":"pgsql_pagination_key_asc","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":91,"slug":"pgsql-pagination-key-desc","name":"pgsql_pagination_key_desc","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":97,"slug":"pgsql-pagination-key-set","name":"pgsql_pagination_key_set","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"keys","type":[{"name":"Key","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"KeySet","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Pagination","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":103,"slug":"to-pgsql-table","name":"to_pgsql_table","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PostgreSqlLoader","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":112,"slug":"to-pgsql-transaction","name":"to_pgsql_transaction","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sinks","type":[{"name":"Loader","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false},{"name":"Sink","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Transactional","namespace":"Flow\\ETL\\Sink","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyaXRlIGV2ZXJ5IHNpbmsgd2l0aGluIFBvc3RncmVTUUwgdHJhbnNhY3Rpb25zLgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":126,"slug":"pgsql-insert-options","name":"pgsql_insert_options","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"skipConflicts","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"conflictColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"conflictConstraint","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"updateColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"InsertOptions","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\LoaderOptions","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBpbnNlcnQgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBsb2FkZXIuCiAqCiAqIEBwYXJhbSBib29sICRza2lwQ29uZmxpY3RzIElmIHRydWUsIHVzZSBPTiBDT05GTElDVCBETyBOT1RISU5HCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGNvbmZsaWN0Q29sdW1ucyBDb2x1bW4gbmFtZXMgZm9yIE9OIENPTkZMSUNUIChjb2x1bW5zKQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGNvbmZsaWN0Q29uc3RyYWludCBDb25zdHJhaW50IG5hbWUgZm9yIE9OIENPTkZMSUNUIE9OIENPTlNUUkFJTlQKICogQHBhcmFtIGxpc3Q8c3RyaW5nPiAkdXBkYXRlQ29sdW1ucyBDb2x1bW5zIHRvIHVwZGF0ZSBvbiBjb25mbGljdCAoZW1wdHkgPSBhbGwgbm9uLWtleSBjb2x1bW5zKQogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":141,"slug":"pgsql-update-options","name":"pgsql_update_options","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"primaryKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UpdateOptions","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\LoaderOptions","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB1cGRhdGUgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBsb2FkZXIuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHByaW1hcnlLZXlzIENvbHVtbnMgdG8gdXNlIGluIFdIRVJFIGNsYXVzZSBmb3IgbWF0Y2hpbmcgcm93cwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":152,"slug":"pgsql-delete-options","name":"pgsql_delete_options","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"primaryKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DeleteOptions","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\LoaderOptions","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBkZWxldGUgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBsb2FkZXIuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHByaW1hcnlLZXlzIENvbHVtbnMgdG8gdXNlIGluIFdIRVJFIGNsYXVzZSBmb3IgbWF0Y2hpbmcgcm93cwogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":164,"slug":"to-pgsql-schema-table","name":"to_pgsql_schema_table","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tableName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"databaseSchema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'public'"},{"name":"typesMap","type":[{"name":"EntryTypesMap","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"options","type":[{"name":"TableOptions","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Table","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBGbG93IFNjaGVtYSBpbnRvIGEgUG9zdGdyZVNRTCB0YWJsZSBkZWZpbml0aW9uLgogKgogKiBAcGFyYW0gc3RyaW5nICRkYXRhYmFzZVNjaGVtYSBQb3N0Z3JlU1FMIHNjaGVtYSAobmFtZXNwYWNlKSB0aGUgdGFibGUgYmVsb25ncyB0bwogKiBAcGFyYW0gP1RhYmxlT3B0aW9ucyAkb3B0aW9ucyB0YWJsZS1sZXZlbCBvcHRpb25zIHRoZSBGbG93IFNjaGVtYSBjYW5ub3QgZXhwcmVzcyAoZS5nLiBVTkxPR0dFRCkKICov"},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":178,"slug":"pgsql-table-to-flow-schema","name":"pgsql_table_to_flow_schema","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"table","type":[{"name":"Table","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typesMap","type":[{"name":"EntryTypesMap","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBQb3N0Z3JlU1FMIHRhYmxlIGRlZmluaXRpb24gaW50byBhIEZsb3cgU2NoZW1hLgogKi8="},{"repository_path":"src\/adapter\/etl-adapter-postgresql\/src\/Flow\/ETL\/Adapter\/PostgreSql\/functions.php","start_line_in_file":184,"slug":"pgsql-schema-sort-by-type","name":"pgsql_schema_sort_by_type","namespace":"Flow\\ETL\\Adapter\\PostgreSql","parameters":[{"name":"typesMap","type":[{"name":"EntryTypesMap","namespace":"Flow\\ETL\\Adapter\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TypeStrategy","namespace":"Flow\\ETL\\Adapter\\PostgreSql\\Schema\\SortingStrategy","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"POSTGRESQL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":15,"slug":"to-seal-upsert","name":"to_seal_upsert","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"engine","type":[{"name":"EngineInterface","namespace":"CmsIg\\Seal","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"index","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SealLoader","namespace":"Flow\\ETL\\Adapter\\Seal","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":21,"slug":"to-seal-delete","name":"to_seal_delete","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"engine","type":[{"name":"EngineInterface","namespace":"CmsIg\\Seal","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"index","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SealLoader","namespace":"Flow\\ETL\\Adapter\\Seal","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":27,"slug":"to-seal-schema","name":"to_seal_schema","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"index_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"identifier","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Schema","namespace":"CmsIg\\Seal\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-seal\/src\/Flow\/ETL\/Adapter\/Seal\/functions.php","start_line_in_file":33,"slug":"seal-schema-to-flow","name":"seal_schema_to_flow","namespace":"Flow\\ETL\\Adapter\\Seal","parameters":[{"name":"schema","type":[{"name":"Schema","namespace":"CmsIg\\Seal\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Schema","namespace":"Flow\\ETL","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SEAL","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/adapter\/etl-adapter-text\/src\/Flow\/ETL\/Adapter\/Text\/functions.php","start_line_in_file":21,"slug":"from-text","name":"from_text","namespace":"Flow\\ETL\\Adapter\\Text","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"TextExtractor","namespace":"Flow\\ETL\\Adapter\\Text","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TEXT","type":"EXTRACTOR"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKi8="},{"repository_path":"src\/adapter\/etl-adapter-text\/src\/Flow\/ETL\/Adapter\/Text\/functions.php","start_line_in_file":31,"slug":"to-text","name":"to_text","namespace":"Flow\\ETL\\Adapter\\Text","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"new_line_separator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'\\n'"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"TextLoader","namespace":"Flow\\ETL\\Adapter\\Text","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TEXT","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gc3RyaW5nICRuZXdfbGluZV9zZXBhcmF0b3IgLSBkZWZhdWx0IFBIUF9FT0wgLSBAZGVwcmVjYXRlZCB1c2Ugd2l0aE5ld0xpbmVTZXBhcmF0b3IgbWV0aG9kIGluc3RlYWQKICov"},{"repository_path":"src\/adapter\/etl-adapter-xml\/src\/Flow\/ETL\/Adapter\/XML\/functions.php","start_line_in_file":38,"slug":"from-xml","name":"from_xml","namespace":"Flow\\ETL\\Adapter\\XML","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"xml_node_path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"''"},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"XMLParserExtractor","namespace":"Flow\\ETL\\Adapter\\XML","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"XML","type":"EXTRACTOR"}},{"name":"DocumentationExample","namespace":"Flow\\Documentation\\Attribute","arguments":{"topic":"reading","example":"xml"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqICBJbiBvcmRlciB0byBpdGVyYXRlIG9ubHkgb3ZlciA8ZWxlbWVudD4gbm9kZXMgdXNlIGBmcm9tX3htbCgkZmlsZSktPndpdGhYTUxOb2RlUGF0aCgncm9vdC9lbGVtZW50cy9lbGVtZW50JylgLgogKgogKiAgPHJvb3Q+CiAqICAgIDxlbGVtZW50cz4KICogICAgICA8ZWxlbWVudD48L2VsZW1lbnQ+CiAqICAgICAgPGVsZW1lbnQ+PC9lbGVtZW50PgogKiAgICA8ZWxlbWVudHM+CiAqICA8L3Jvb3Q+CiAqCiAqICBYTUwgTm9kZSBQYXRoIGRvZXMgbm90IHN1cHBvcnQgYXR0cmlidXRlcyBhbmQgaXQncyBub3QgeHBhdGgsIGl0IGlzIGp1c3QgYSBzZXF1ZW5jZQogKiAgb2Ygbm9kZSBuYW1lcyBzZXBhcmF0ZWQgd2l0aCBzbGFzaC4KICoKICogQHBhcmFtIFBhdGh8c3RyaW5nICRwYXRoCiAqIEBwYXJhbSBzdHJpbmcgJHhtbF9ub2RlX3BhdGggLSBAZGVwcmVjYXRlZCB1c2UgYGZyb21feG1sKCRmaWxlKS0+d2l0aFhNTE5vZGVQYXRoKCR4bWxOb2RlUGF0aClgIG1ldGhvZCBpbnN0ZWFkCiAqLw=="},{"repository_path":"src\/adapter\/etl-adapter-xml\/src\/Flow\/ETL\/Adapter\/XML\/functions.php","start_line_in_file":57,"slug":"to-xml","name":"to_xml","namespace":"Flow\\ETL\\Adapter\\XML","parameters":[{"name":"path","type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"root_element_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'rows'"},{"name":"row_element_name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'row'"},{"name":"attribute_prefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'_'"},{"name":"date_time_format","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'Y-m-d\\\\TH:i:s.uP'"},{"name":"xml_writer","type":[{"name":"XMLWriter","namespace":"Flow\\ETL\\Adapter\\XML","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\ETL\\Adapter\\XML\\XMLWriter\\StringXMLWriter::..."},{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Local\\NativeLocalFilesystem::..."}],"return_type":[{"name":"XMLLoader","namespace":"Flow\\ETL\\Adapter\\XML\\Loader","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"XML","type":"LOADER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBQYXRofHN0cmluZyAkcGF0aAogKiBAcGFyYW0gc3RyaW5nICRyb290X2VsZW1lbnRfbmFtZSAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aFJvb3RFbGVtZW50TmFtZSgpYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRyb3dfZWxlbWVudF9uYW1lIC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoUm93RWxlbWVudE5hbWUoKWAgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIHN0cmluZyAkYXR0cmlidXRlX3ByZWZpeCAtIEBkZXByZWNhdGVkIHVzZSBgd2l0aEF0dHJpYnV0ZVByZWZpeCgpYCBtZXRob2QgaW5zdGVhZAogKiBAcGFyYW0gc3RyaW5nICRkYXRlX3RpbWVfZm9ybWF0IC0gQGRlcHJlY2F0ZWQgdXNlIGB3aXRoRGF0ZVRpbWVGb3JtYXQoKWAgbWV0aG9kIGluc3RlYWQKICogQHBhcmFtIFhNTFdyaXRlciAkeG1sX3dyaXRlcgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":32,"slug":"mount","name":"mount","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Mount","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":38,"slug":"partition","name":"partition","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"value","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Partition","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":44,"slug":"partitions","name":"partitions","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"partition","type":[{"name":"Partition","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Partitions","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":63,"slug":"path","name":"path","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Path","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhdGggc3VwcG9ydHMgZ2xvYiBwYXR0ZXJucy4KICogRXhhbXBsZXM6CiAqICAtIHBhdGgoJyouY3N2JykgLSBhbnkgY3N2IGZpbGUgaW4gY3VycmVudCBkaXJlY3RvcnkKICogIC0gcGF0aCgnLyoqIC8gKi5jc3YnKSAtIGFueSBjc3YgZmlsZSBpbiBhbnkgc3ViZGlyZWN0b3J5IChyZW1vdmUgZW1wdHkgc3BhY2VzKQogKiAgLSBwYXRoKCcvZGlyL3BhcnRpdGlvbj0qIC8qLnBhcnF1ZXQnKSAtIGFueSBwYXJxdWV0IGZpbGUgaW4gZ2l2ZW4gcGFydGl0aW9uIGRpcmVjdG9yeS4KICoKICogR2xvYiBwYXR0ZXJuIGlzIGFsc28gc3VwcG9ydGVkIGJ5IHJlbW90ZSBmaWxlc3lzdGVtcyBsaWtlIEF6dXJlCiAqCiAqICAtIHBhdGgoJ2F6dXJlLWJsb2I6Ly9kaXJlY3RvcnkvKi5jc3YnKSAtIGFueSBjc3YgZmlsZSBpbiBnaXZlbiBkaXJlY3RvcnkKICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbnVsbHxib29sfGZsb2F0fGludHxzdHJpbmd8XFVuaXRFbnVtPnxQYXRoXE9wdGlvbnMgJG9wdGlvbnMKICov"},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":74,"slug":"path-real","name":"path_real","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Path","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJlc29sdmUgcmVhbCBwYXRoIGZyb20gZ2l2ZW4gcGF0aC4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgbnVsbHxib29sfGZsb2F0fGludHxzdHJpbmd8XFVuaXRFbnVtPiAkb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":80,"slug":"native-local-filesystem","name":"native_local_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'file'"}],"return_type":[{"name":"NativeLocalFilesystem","namespace":"Flow\\Filesystem\\Local","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":90,"slug":"stdout-filesystem","name":"stdout_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'stdout'"}],"return_type":[{"name":"StdOutFilesystem","namespace":"Flow\\Filesystem\\Local","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyaXRlLW9ubHkgZmlsZXN5c3RlbSB1c2VmdWwgd2hlbiB3ZSBqdXN0IHdhbnQgdG8gd3JpdGUgdGhlIG91dHB1dCB0byBzdGRvdXQuCiAqIFRoZSBtYWluIHVzZSBjYXNlIGlzIGZvciBzdHJlYW1pbmcgZGF0YXNldHMgb3ZlciBodHRwLgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":99,"slug":"memory-filesystem","name":"memory_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'memory'"}],"return_type":[{"name":"MemoryFilesystem","namespace":"Flow\\Filesystem\\Local","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBtZW1vcnkgZmlsZXN5c3RlbSBhbmQgd3JpdGVzIGRhdGEgdG8gaXQgaW4gbWVtb3J5LgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":110,"slug":"fstab","name":"fstab","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"filesystems","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"FilesystemTable","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBmaWxlc3lzdGVtIHRhYmxlIHdpdGggZ2l2ZW4gZmlsZXN5c3RlbXMuCiAqIEZpbGVzeXN0ZW1zIGNhbiBiZSBhbHNvIG1vdW50ZWQgbGF0ZXIuCiAqIElmIG5vIGZpbGVzeXN0ZW1zIGFyZSBwcm92aWRlZCwgbG9jYWwgZmlsZXN5c3RlbSBpcyBtb3VudGVkLgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":126,"slug":"traceable-filesystem","name":"traceable_filesystem","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"filesystem","type":[{"name":"Filesystem","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"telemetryConfig","type":[{"name":"FilesystemTelemetryConfig","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TraceableFilesystem","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYSBmaWxlc3lzdGVtIHdpdGggdGVsZW1ldHJ5IHRyYWNpbmcgc3VwcG9ydC4KICogQWxsIGZpbGVzeXN0ZW0gYW5kIHN0cmVhbSBvcGVyYXRpb25zIHdpbGwgYmUgdHJhY2VkIGFjY29yZGluZyB0byB0aGUgY29uZmlndXJhdGlvbi4KICov"},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":135,"slug":"filesystem-telemetry-config","name":"filesystem_telemetry_config","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"telemetry","type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"FilesystemTelemetryOptions","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"FilesystemTelemetryConfig","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRlbGVtZXRyeSBjb25maWd1cmF0aW9uIGZvciB0aGUgZmlsZXN5c3RlbS4KICov"},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":150,"slug":"filesystem-telemetry-options","name":"filesystem_telemetry_options","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"trace_streams","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"collect_metrics","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"FilesystemTelemetryOptions","namespace":"Flow\\Filesystem\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBvcHRpb25zIGZvciBmaWxlc3lzdGVtIHRlbGVtZXRyeS4KICoKICogQHBhcmFtIGJvb2wgJHRyYWNlX3N0cmVhbXMgQ3JlYXRlIGEgc2luZ2xlIHNwYW4gcGVyIHN0cmVhbSBsaWZlY3ljbGUgKGRlZmF1bHQ6IE9OKQogKiBAcGFyYW0gYm9vbCAkY29sbGVjdF9tZXRyaWNzIENvbGxlY3QgbWV0cmljcyBmb3IgYnl0ZXMvb3BlcmF0aW9uIGNvdW50cyAoZGVmYXVsdDogT04pCiAqLw=="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":163,"slug":"file-copy","name":"file_copy","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"table","type":[{"name":"FilesystemTable","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"OperationOptions","namespace":"Flow\\Filesystem\\Operations","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Copy","namespace":"Flow\\Filesystem\\Operations","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvcHkgYSBmaWxlIGZyb20gb25lIHBhdGggdG8gYW5vdGhlciwgYWNyb3NzIGFueSBmaWxlc3lzdGVtcyBtb3VudGVkIGluIHRoZSB0YWJsZS4KICogQWx3YXlzIHN0cmVhbXMgYnl0ZXM7IHNhbWUtZmlsZXN5c3RlbSBjb3BpZXMgZG8gbm90IHVzZSBzZXJ2ZXItc2lkZSBvcHRpbWl6YXRpb25zCiAqIGJlY2F1c2UgYEZpbGVzeXN0ZW06Om12YCBpcyBhIG1vdmUsIG5vdCBhIGNvcHkuCiAqLw=="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":174,"slug":"file-move","name":"file_move","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"table","type":[{"name":"FilesystemTable","namespace":"Flow\\Filesystem","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"OperationOptions","namespace":"Flow\\Filesystem\\Operations","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Move","namespace":"Flow\\Filesystem\\Operations","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE1vdmUgYSBmaWxlIGZyb20gb25lIHBhdGggdG8gYW5vdGhlciwgYWNyb3NzIGFueSBmaWxlc3lzdGVtcyBtb3VudGVkIGluIHRoZSB0YWJsZS4KICogSW50cmEtZmlsZXN5c3RlbSBtb3ZlcyBkZWxlZ2F0ZSB0byBgRmlsZXN5c3RlbTo6bXZgIGZvciBzZXJ2ZXItc2lkZSBvcHRpbWl6YXRpb25zOwogKiBjcm9zcy1maWxlc3lzdGVtIG1vdmVzIHN0cmVhbS1jb3B5IHRoZW4gcmVtb3ZlIHRoZSBzb3VyY2UgKG5vbi1hdG9taWMpLgogKi8="},{"repository_path":"src\/lib\/filesystem\/src\/Flow\/Filesystem\/DSL\/functions.php","start_line_in_file":185,"slug":"operation-options","name":"operation_options","namespace":"Flow\\Filesystem\\DSL","parameters":[{"name":"chunkSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"8192"}],"return_type":[{"name":"OperationOptions","namespace":"Flow\\Filesystem\\Operations","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE9wdGlvbnMgc2hhcmVkIGJ5IGZpbGVzeXN0ZW0gb3BlcmF0aW9ucy4KICoKICogQHBhcmFtIGludCAkY2h1bmtTaXplIE51bWJlciBvZiBieXRlcyByZWFkL3dyaXR0ZW4gcGVyIGl0ZXJhdGlvbiB3aGVuIHN0cmVhbWluZyBhY3Jvc3MgZmlsZXN5c3RlbXMgKGRlZmF1bHQ6IDgxOTIpCiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":65,"slug":"type-structure","name":"type_structure","namespace":"Flow\\Types\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"StructureType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBhcnJheTxhcnJheS1rZXksIFN0cnVjdHVyZUVsZW1lbnQ8VD58VHlwZTxUPj4gJGVsZW1lbnRzCiAqCiAqIEByZXR1cm4gU3RydWN0dXJlVHlwZTxhcnJheTxhcnJheS1rZXksIFQ+PgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":80,"slug":"structure-element","name":"structure_element","namespace":"Flow\\Types\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"optional","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"StructureElement","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqIEB0ZW1wbGF0ZSBUT3B0aW9uYWwgb2YgYm9vbAogKgogKiBAcGFyYW0gVHlwZTxUPiAkdHlwZQogKiBAcGFyYW0gVE9wdGlvbmFsICRvcHRpb25hbAogKgogKiBAcmV0dXJuIFN0cnVjdHVyZUVsZW1lbnQ8VCwgVE9wdGlvbmFsPgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":95,"slug":"type-union","name":"type_union","namespace":"Flow\\Types\\DSL","parameters":[{"name":"first","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"second","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"UnionType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICRmaXJzdAogKiBAcGFyYW0gVHlwZTxUPiAkc2Vjb25kCiAqIEBwYXJhbSBUeXBlPFQ+IC4uLiR0eXBlcwogKgogKiBAcmV0dXJuIFVuaW9uVHlwZTxULCBUPgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":116,"slug":"type-intersection","name":"type_intersection","namespace":"Flow\\Types\\DSL","parameters":[{"name":"first","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"second","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"IntersectionType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICRmaXJzdAogKiBAcGFyYW0gVHlwZTxUPiAkc2Vjb25kCiAqIEBwYXJhbSBUeXBlPFQ+IC4uLiR0eXBlcwogKgogKiBAcmV0dXJuIEludGVyc2VjdGlvblR5cGU8VCwgVD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":128,"slug":"type-numeric-string","name":"type_numeric_string","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"NumericStringType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":141,"slug":"type-optional","name":"type_optional","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OptionalType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqCiAqIEByZXR1cm4gT3B0aW9uYWxUeXBlPFQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":152,"slug":"type-from-array","name":"type_from_array","namespace":"Flow\\Types\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPiAkZGF0YQogKgogKiBAcmV0dXJuIFR5cGU8bWl4ZWQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":163,"slug":"type-is-nullable","name":"type_is_nullable","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":179,"slug":"type-bare","name":"type_bare","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0cmlwIGV4YWN0bHkgb25lIGxldmVsIG9mIG51bGxhYmlsaXR5LCB3aGljaGV2ZXIgb2YgdGhlIHR3byBzcGVsbGluZ3MgY2FycmllcyBpdAogKiAoT3B0aW9uYWxUeXBlLCBvciBhIFVuaW9uVHlwZSBjb250YWluaW5nIE51bGxUeXBlKS4gVG90YWw6IGEgTk9UIE5VTEwgdHlwZSBpcyByZXR1cm5lZCB1bmNoYW5nZWQuCiAqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqCiAqIEByZXR1cm4gVHlwZTxtaXhlZD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":189,"slug":"type-equals","name":"type_equals","namespace":"Flow\\Types\\DSL","parameters":[{"name":"left","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBUeXBlPG1peGVkPiAkbGVmdAogKiBAcGFyYW0gVHlwZTxtaXhlZD4gJHJpZ2h0CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":202,"slug":"types","name":"types","namespace":"Flow\\Types\\DSL","parameters":[{"name":"types","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Types","namespace":"Flow\\Types\\Type","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+IC4uLiR0eXBlcwogKgogKiBAcmV0dXJuIFR5cGVzPFQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":215,"slug":"type-list","name":"type_list","namespace":"Flow\\Types\\DSL","parameters":[{"name":"element","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ListType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICRlbGVtZW50CiAqCiAqIEByZXR1cm4gTGlzdFR5cGU8VD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":230,"slug":"type-map","name":"type_map","namespace":"Flow\\Types\\DSL","parameters":[{"name":"key_type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"value_type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"MapType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUS2V5IG9mIGFycmF5LWtleQogKiBAdGVtcGxhdGUgVFZhbHVlCiAqCiAqIEBwYXJhbSBUeXBlPFRLZXk+ICRrZXlfdHlwZQogKiBAcGFyYW0gVHlwZTxUVmFsdWU+ICR2YWx1ZV90eXBlCiAqCiAqIEByZXR1cm4gTWFwVHlwZTxUS2V5LCBUVmFsdWU+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":236,"slug":"type-json","name":"type_json","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"JsonType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":242,"slug":"type-datetime","name":"type_datetime","namespace":"Flow\\Types\\DSL","parameters":[{"name":"zone","type":[{"name":"DateTimeZone","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'UTC'"}],"return_type":[{"name":"DateTimeType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":248,"slug":"type-date","name":"type_date","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"DateType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":254,"slug":"type-time","name":"type_time","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"TimeType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":260,"slug":"type-time-zone","name":"type_time_zone","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"TimeZoneType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":266,"slug":"type-xml","name":"type_xml","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"XMLType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":272,"slug":"type-xml-element","name":"type_xml_element","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"XMLElementType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":278,"slug":"type-uuid","name":"type_uuid","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"UuidType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":284,"slug":"type-integer","name":"type_integer","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"IntegerType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":290,"slug":"type-string","name":"type_string","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"StringType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":296,"slug":"type-float","name":"type_float","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"FloatType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":302,"slug":"type-boolean","name":"type_boolean","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"BooleanType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":315,"slug":"type-instance-of","name":"type_instance_of","namespace":"Flow\\Types\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"InstanceOfType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICRjbGFzcwogKgogKiBAcmV0dXJuIEluc3RhbmNlT2ZUeXBlPFQ+CiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":321,"slug":"type-object","name":"type_object","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ObjectType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":327,"slug":"type-scalar","name":"type_scalar","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ScalarType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":333,"slug":"type-resource","name":"type_resource","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ResourceType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":339,"slug":"type-array","name":"type_array","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"ArrayType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":345,"slug":"type-callable","name":"type_callable","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"CallableType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":351,"slug":"type-null","name":"type_null","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"NullType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":357,"slug":"type-mixed","name":"type_mixed","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"MixedType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":363,"slug":"type-positive-integer","name":"type_positive_integer","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"PositiveIntegerType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":369,"slug":"type-non-empty-string","name":"type_non_empty_string","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"NonEmptyStringType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":375,"slug":"type-empty-array","name":"type_empty_array","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"EmptyArrayType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":388,"slug":"type-enum","name":"type_enum","namespace":"Flow\\Types\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnumType","namespace":"Flow\\Types\\Type\\Native","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIFVuaXRFbnVtCiAqCiAqIEBwYXJhbSBjbGFzcy1zdHJpbmc8VD4gJGNsYXNzCiAqCiAqIEByZXR1cm4gRW51bVR5cGU8VD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":401,"slug":"type-literal","name":"type_literal","namespace":"Flow\\Types\\DSL","parameters":[{"name":"value","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"LiteralType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIGJvb2x8ZmxvYXR8aW50fHN0cmluZwogKgogKiBAcGFyYW0gVCAkdmFsdWUKICoKICogQHJldHVybiBMaXRlcmFsVHlwZTxUPgogKi8="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":407,"slug":"type-html","name":"type_html","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"HTMLType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":413,"slug":"type-html-element","name":"type_html_element","namespace":"Flow\\Types\\DSL","parameters":[],"return_type":[{"name":"HTMLElementType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":425,"slug":"type-is","name":"type_is","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typeClass","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqIEBwYXJhbSBjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+ICR0eXBlQ2xhc3MKICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":438,"slug":"type-is-any","name":"type_is_any","namespace":"Flow\\Types\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typeClass","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"typeClasses","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUCiAqCiAqIEBwYXJhbSBUeXBlPFQ+ICR0eXBlCiAqIEBwYXJhbSBjbGFzcy1zdHJpbmc8VHlwZTxtaXhlZD4+ICR0eXBlQ2xhc3MKICogQHBhcmFtIGNsYXNzLXN0cmluZzxUeXBlPG1peGVkPj4gLi4uJHR5cGVDbGFzc2VzCiAqLw=="},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":447,"slug":"get-type","name":"get_type","namespace":"Flow\\Types\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gVHlwZTxtaXhlZD4KICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":460,"slug":"type-class-string","name":"type_class_string","namespace":"Flow\\Types\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ClassStringType","namespace":"Flow\\Types\\Type\\Logical","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gbnVsbHxjbGFzcy1zdHJpbmc8VD4gJGNsYXNzCiAqCiAqIEByZXR1cm4gKCRjbGFzcyBpcyBudWxsID8gQ2xhc3NTdHJpbmdUeXBlPGNsYXNzLXN0cmluZz4gOiBDbGFzc1N0cmluZ1R5cGU8Y2xhc3Mtc3RyaW5nPFQ+PikKICov"},{"repository_path":"src\/lib\/types\/src\/Flow\/Types\/DSL\/functions.php","start_line_in_file":466,"slug":"dom-element-to-string","name":"dom_element_to_string","namespace":"Flow\\Types\\DSL","parameters":[{"name":"element","type":[{"name":"DOMElement","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"format_output","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"preserver_white_space","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"false","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TYPES","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/parquet\/src\/Flow\/Parquet\/DSL\/functions.php","start_line_in_file":14,"slug":"parquet-column","name":"parquet_column","namespace":"Flow\\Parquet\\DSL","parameters":[{"name":"path","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnRef","namespace":"Flow\\Parquet\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/parquet\/src\/Flow\/Parquet\/DSL\/functions.php","start_line_in_file":20,"slug":"parquet-query","name":"parquet_query","namespace":"Flow\\Parquet\\DSL","parameters":[],"return_type":[{"name":"Query","namespace":"Flow\\Parquet","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PARQUET","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":134,"slug":"column","name":"column","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnDefinition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbHVtbiBkZWZpbml0aW9uIGZvciBDUkVBVEUgVEFCTEUuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgQ29sdW1uIG5hbWUKICogQHBhcmFtIENvbHVtblR5cGUgJHR5cGUgQ29sdW1uIGRhdGEgdHlwZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":143,"slug":"catalog","name":"catalog","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"schemas","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Catalog","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYT4gJHNjaGVtYXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":154,"slug":"primary-key","name":"primary_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"PrimaryKeyConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBSSU1BUlkgS0VZIGNvbnN0cmFpbnQuCiAqCiAqIEBwYXJhbSBzdHJpbmcgLi4uJGNvbHVtbnMgQ29sdW1ucyB0aGF0IGZvcm0gdGhlIHByaW1hcnkga2V5CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":165,"slug":"unique-constraint","name":"unique_constraint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"UniqueConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFVOSVFVRSBjb25zdHJhaW50LgogKgogKiBAcGFyYW0gc3RyaW5nIC4uLiRjb2x1bW5zIENvbHVtbnMgdGhhdCBtdXN0IGJlIHVuaXF1ZSB0b2dldGhlcgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":178,"slug":"foreign-key","name":"foreign_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceTable","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ForeignKeyConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEZPUkVJR04gS0VZIGNvbnN0cmFpbnQuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGNvbHVtbnMgTG9jYWwgY29sdW1ucwogKiBAcGFyYW0gc3RyaW5nICRyZWZlcmVuY2VUYWJsZSBSZWZlcmVuY2VkIHRhYmxlCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHJlZmVyZW5jZUNvbHVtbnMgUmVmZXJlbmNlZCBjb2x1bW5zIChkZWZhdWx0cyB0byBzYW1lIGFzICRjb2x1bW5zIGlmIGVtcHR5KQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":187,"slug":"check-constraint","name":"check_constraint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"condition","type":[{"name":"Condition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CheckConstraint","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENIRUNLIGNvbnN0cmFpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":218,"slug":"create","name":"create","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"CreateFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZhY3RvcnkgZm9yIGJ1aWxkaW5nIENSRUFURSBzdGF0ZW1lbnRzLgogKgogKiBQcm92aWRlcyBhIHVuaWZpZWQgZW50cnkgcG9pbnQgZm9yIGFsbCBDUkVBVEUgb3BlcmF0aW9uczoKICogLSBjcmVhdGUoKS0+dGFibGUoKSAtIENSRUFURSBUQUJMRQogKiAtIGNyZWF0ZSgpLT50YWJsZUFzKCkgLSBDUkVBVEUgVEFCTEUgQVMKICogLSBjcmVhdGUoKS0+aW5kZXgoKSAtIENSRUFURSBJTkRFWAogKiAtIGNyZWF0ZSgpLT52aWV3KCkgLSBDUkVBVEUgVklFVwogKiAtIGNyZWF0ZSgpLT5tYXRlcmlhbGl6ZWRWaWV3KCkgLSBDUkVBVEUgTUFURVJJQUxJWkVEIFZJRVcKICogLSBjcmVhdGUoKS0+c2VxdWVuY2UoKSAtIENSRUFURSBTRVFVRU5DRQogKiAtIGNyZWF0ZSgpLT5zY2hlbWEoKSAtIENSRUFURSBTQ0hFTUEKICogLSBjcmVhdGUoKS0+cm9sZSgpIC0gQ1JFQVRFIFJPTEUKICogLSBjcmVhdGUoKS0+ZnVuY3Rpb24oKSAtIENSRUFURSBGVU5DVElPTgogKiAtIGNyZWF0ZSgpLT5wcm9jZWR1cmUoKSAtIENSRUFURSBQUk9DRURVUkUKICogLSBjcmVhdGUoKS0+dHJpZ2dlcigpIC0gQ1JFQVRFIFRSSUdHRVIKICogLSBjcmVhdGUoKS0+cnVsZSgpIC0gQ1JFQVRFIFJVTEUKICogLSBjcmVhdGUoKS0+ZXh0ZW5zaW9uKCkgLSBDUkVBVEUgRVhURU5TSU9OCiAqIC0gY3JlYXRlKCktPmNvbXBvc2l0ZVR5cGUoKSAtIENSRUFURSBUWVBFIChjb21wb3NpdGUpCiAqIC0gY3JlYXRlKCktPmVudW1UeXBlKCkgLSBDUkVBVEUgVFlQRSAoZW51bSkKICogLSBjcmVhdGUoKS0+cmFuZ2VUeXBlKCkgLSBDUkVBVEUgVFlQRSAocmFuZ2UpCiAqIC0gY3JlYXRlKCktPmRvbWFpbigpIC0gQ1JFQVRFIERPTUFJTgogKgogKiBFeGFtcGxlOiBjcmVhdGUoKS0+dGFibGUoJ3VzZXJzJyktPmNvbHVtbnMoY29sX2RlZignaWQnLCBjb2x1bW5fdHlwZV9zZXJpYWwoKSkpCiAqIEV4YW1wbGU6IGNyZWF0ZSgpLT5pbmRleCgnaWR4X2VtYWlsJyktPm9uKCd1c2VycycpLT5jb2x1bW5zKCdlbWFpbCcpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":247,"slug":"drop","name":"drop","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"DropFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZhY3RvcnkgZm9yIGJ1aWxkaW5nIERST1Agc3RhdGVtZW50cy4KICoKICogUHJvdmlkZXMgYSB1bmlmaWVkIGVudHJ5IHBvaW50IGZvciBhbGwgRFJPUCBvcGVyYXRpb25zOgogKiAtIGRyb3AoKS0+dGFibGUoKSAtIERST1AgVEFCTEUKICogLSBkcm9wKCktPmluZGV4KCkgLSBEUk9QIElOREVYCiAqIC0gZHJvcCgpLT52aWV3KCkgLSBEUk9QIFZJRVcKICogLSBkcm9wKCktPm1hdGVyaWFsaXplZFZpZXcoKSAtIERST1AgTUFURVJJQUxJWkVEIFZJRVcKICogLSBkcm9wKCktPnNlcXVlbmNlKCkgLSBEUk9QIFNFUVVFTkNFCiAqIC0gZHJvcCgpLT5zY2hlbWEoKSAtIERST1AgU0NIRU1BCiAqIC0gZHJvcCgpLT5yb2xlKCkgLSBEUk9QIFJPTEUKICogLSBkcm9wKCktPmZ1bmN0aW9uKCkgLSBEUk9QIEZVTkNUSU9OCiAqIC0gZHJvcCgpLT5wcm9jZWR1cmUoKSAtIERST1AgUFJPQ0VEVVJFCiAqIC0gZHJvcCgpLT50cmlnZ2VyKCkgLSBEUk9QIFRSSUdHRVIKICogLSBkcm9wKCktPnJ1bGUoKSAtIERST1AgUlVMRQogKiAtIGRyb3AoKS0+ZXh0ZW5zaW9uKCkgLSBEUk9QIEVYVEVOU0lPTgogKiAtIGRyb3AoKS0+dHlwZSgpIC0gRFJPUCBUWVBFCiAqIC0gZHJvcCgpLT5kb21haW4oKSAtIERST1AgRE9NQUlOCiAqIC0gZHJvcCgpLT5vd25lZCgpIC0gRFJPUCBPV05FRAogKgogKiBFeGFtcGxlOiBkcm9wKCktPnRhYmxlKCd1c2VycycsICdvcmRlcnMnKS0+aWZFeGlzdHMoKS0+Y2FzY2FkZSgpCiAqIEV4YW1wbGU6IGRyb3AoKS0+aW5kZXgoJ2lkeF9lbWFpbCcpLT5pZkV4aXN0cygpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":281,"slug":"alter","name":"alter","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AlterFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZhY3RvcnkgZm9yIGJ1aWxkaW5nIEFMVEVSIHN0YXRlbWVudHMuCiAqCiAqIFByb3ZpZGVzIGEgdW5pZmllZCBlbnRyeSBwb2ludCBmb3IgYWxsIEFMVEVSIG9wZXJhdGlvbnM6CiAqIC0gYWx0ZXIoKS0+dGFibGUoKSAtIEFMVEVSIFRBQkxFCiAqIC0gYWx0ZXIoKS0+aW5kZXgoKSAtIEFMVEVSIElOREVYCiAqIC0gYWx0ZXIoKS0+dmlldygpIC0gQUxURVIgVklFVwogKiAtIGFsdGVyKCktPm1hdGVyaWFsaXplZFZpZXcoKSAtIEFMVEVSIE1BVEVSSUFMSVpFRCBWSUVXCiAqIC0gYWx0ZXIoKS0+c2VxdWVuY2UoKSAtIEFMVEVSIFNFUVVFTkNFCiAqIC0gYWx0ZXIoKS0+c2NoZW1hKCkgLSBBTFRFUiBTQ0hFTUEKICogLSBhbHRlcigpLT5yb2xlKCkgLSBBTFRFUiBST0xFCiAqIC0gYWx0ZXIoKS0+ZnVuY3Rpb24oKSAtIEFMVEVSIEZVTkNUSU9OCiAqIC0gYWx0ZXIoKS0+cHJvY2VkdXJlKCkgLSBBTFRFUiBQUk9DRURVUkUKICogLSBhbHRlcigpLT50cmlnZ2VyKCkgLSBBTFRFUiBUUklHR0VSCiAqIC0gYWx0ZXIoKS0+ZXh0ZW5zaW9uKCkgLSBBTFRFUiBFWFRFTlNJT04KICogLSBhbHRlcigpLT5lbnVtVHlwZSgpIC0gQUxURVIgVFlQRSAoZW51bSkKICogLSBhbHRlcigpLT5kb21haW4oKSAtIEFMVEVSIERPTUFJTgogKgogKiBSZW5hbWUgb3BlcmF0aW9ucyBhcmUgYWxzbyB1bmRlciBhbHRlcigpOgogKiAtIGFsdGVyKCktPmluZGV4KCdvbGQnKS0+cmVuYW1lVG8oJ25ldycpCiAqIC0gYWx0ZXIoKS0+dmlldygnb2xkJyktPnJlbmFtZVRvKCduZXcnKQogKiAtIGFsdGVyKCktPnNjaGVtYSgnb2xkJyktPnJlbmFtZVRvKCduZXcnKQogKiAtIGFsdGVyKCktPnJvbGUoJ29sZCcpLT5yZW5hbWVUbygnbmV3JykKICogLSBhbHRlcigpLT50cmlnZ2VyKCdvbGQnKS0+b24oJ3RhYmxlJyktPnJlbmFtZVRvKCduZXcnKQogKgogKiBFeGFtcGxlOiBhbHRlcigpLT50YWJsZSgndXNlcnMnKS0+YWRkQ29sdW1uKGNvbF9kZWYoJ2VtYWlsJywgY29sdW1uX3R5cGVfdGV4dCgpKSkKICogRXhhbXBsZTogYWx0ZXIoKS0+c2VxdWVuY2UoJ3VzZXJfaWRfc2VxJyktPnJlc3RhcnQoMTAwMCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":292,"slug":"truncate-table","name":"truncate_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"TruncateFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Truncate","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRSVU5DQVRFIFRBQkxFIGJ1aWxkZXIuCiAqCiAqIEBwYXJhbSBzdHJpbmcgLi4uJHRhYmxlcyBUYWJsZSBuYW1lcyB0byB0cnVuY2F0ZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":310,"slug":"refresh-materialized-view","name":"refresh_materialized_view","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"RefreshMatViewOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\View\\RefreshMaterializedView","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFRlJFU0ggTUFURVJJQUxJWkVEIFZJRVcgYnVpbGRlci4KICoKICogRXhhbXBsZTogcmVmcmVzaF9tYXRlcmlhbGl6ZWRfdmlldygndXNlcl9zdGF0cycpCiAqIFByb2R1Y2VzOiBSRUZSRVNIIE1BVEVSSUFMSVpFRCBWSUVXIHVzZXJfc3RhdHMKICoKICogRXhhbXBsZTogcmVmcmVzaF9tYXRlcmlhbGl6ZWRfdmlldygndXNlcl9zdGF0cycpLT5jb25jdXJyZW50bHkoKS0+d2l0aERhdGEoKQogKiBQcm9kdWNlczogUkVGUkVTSCBNQVRFUklBTElaRUQgVklFVyBDT05DVVJSRU5UTFkgdXNlcl9zdGF0cyBXSVRIIERBVEEKICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBWaWV3IG5hbWUgKG1heSBpbmNsdWRlIHNjaGVtYSBhcyAic2NoZW1hLnZpZXciKQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNjaGVtYSBTY2hlbWEgbmFtZSAob3B0aW9uYWwsIG92ZXJyaWRlcyBwYXJzZWQgc2NoZW1hKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":319,"slug":"ref-action-cascade","name":"ref_action_cascade","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIENBU0NBREUgcmVmZXJlbnRpYWwgYWN0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":328,"slug":"ref-action-restrict","name":"ref_action_restrict","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIFJFU1RSSUNUIHJlZmVyZW50aWFsIGFjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":337,"slug":"ref-action-set-null","name":"ref_action_set_null","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIFNFVCBOVUxMIHJlZmVyZW50aWFsIGFjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":346,"slug":"ref-action-set-default","name":"ref_action_set_default","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIFNFVCBERUZBVUxUIHJlZmVyZW50aWFsIGFjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":355,"slug":"ref-action-no-action","name":"ref_action_no_action","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCBhIE5PIEFDVElPTiByZWZlcmVudGlhbCBhY3Rpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":370,"slug":"reindex-index","name":"reindex_index","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBJTkRFWCBzdGF0ZW1lbnQuCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5jb25jdXJyZW50bHkoKSwgLT52ZXJib3NlKCksIC0+dGFibGVzcGFjZSgpCiAqCiAqIEV4YW1wbGU6IHJlaW5kZXhfaW5kZXgoJ2lkeF91c2Vyc19lbWFpbCcpLT5jb25jdXJyZW50bHkoKQogKgogKiBAcGFyYW0gc3RyaW5nICRuYW1lIFRoZSBpbmRleCBuYW1lIChtYXkgaW5jbHVkZSBzY2hlbWE6IHNjaGVtYS5pbmRleCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":385,"slug":"reindex-table","name":"reindex_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBUQUJMRSBzdGF0ZW1lbnQuCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5jb25jdXJyZW50bHkoKSwgLT52ZXJib3NlKCksIC0+dGFibGVzcGFjZSgpCiAqCiAqIEV4YW1wbGU6IHJlaW5kZXhfdGFibGUoJ3VzZXJzJyktPmNvbmN1cnJlbnRseSgpCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGhlIHRhYmxlIG5hbWUgKG1heSBpbmNsdWRlIHNjaGVtYTogc2NoZW1hLnRhYmxlKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":400,"slug":"reindex-schema","name":"reindex_schema","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBTQ0hFTUEgc3RhdGVtZW50LgogKgogKiBVc2UgY2hhaW5hYmxlIG1ldGhvZHM6IC0+Y29uY3VycmVudGx5KCksIC0+dmVyYm9zZSgpLCAtPnRhYmxlc3BhY2UoKQogKgogKiBFeGFtcGxlOiByZWluZGV4X3NjaGVtYSgncHVibGljJyktPmNvbmN1cnJlbnRseSgpCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGhlIHNjaGVtYSBuYW1lCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":415,"slug":"reindex-database","name":"reindex_database","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ReindexFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index\\Reindex","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFN0YXJ0IGJ1aWxkaW5nIGEgUkVJTkRFWCBEQVRBQkFTRSBzdGF0ZW1lbnQuCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5jb25jdXJyZW50bHkoKSwgLT52ZXJib3NlKCksIC0+dGFibGVzcGFjZSgpCiAqCiAqIEV4YW1wbGU6IHJlaW5kZXhfZGF0YWJhc2UoJ215ZGInKS0+Y29uY3VycmVudGx5KCkKICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBUaGUgZGF0YWJhc2UgbmFtZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":430,"slug":"index-col","name":"index_col","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"IndexColumn","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbmRleCBjb2x1bW4gc3BlY2lmaWNhdGlvbi4KICoKICogVXNlIGNoYWluYWJsZSBtZXRob2RzOiAtPmFzYygpLCAtPmRlc2MoKSwgLT5udWxsc0ZpcnN0KCksIC0+bnVsbHNMYXN0KCksIC0+b3BjbGFzcygpLCAtPmNvbGxhdGUoKQogKgogKiBFeGFtcGxlOiBpbmRleF9jb2woJ2VtYWlsJyktPmRlc2MoKS0+bnVsbHNMYXN0KCkKICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBUaGUgY29sdW1uIG5hbWUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":445,"slug":"index-expr","name":"index_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expression","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"IndexColumn","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"SCHEMA"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbmRleCBjb2x1bW4gc3BlY2lmaWNhdGlvbiBmcm9tIGFuIGV4cHJlc3Npb24uCiAqCiAqIFVzZSBjaGFpbmFibGUgbWV0aG9kczogLT5hc2MoKSwgLT5kZXNjKCksIC0+bnVsbHNGaXJzdCgpLCAtPm51bGxzTGFzdCgpLCAtPm9wY2xhc3MoKSwgLT5jb2xsYXRlKCkKICoKICogRXhhbXBsZTogaW5kZXhfZXhwcihmbl9jYWxsKCdsb3dlcicsIGNvbCgnZW1haWwnKSkpLT5kZXNjKCkKICoKICogQHBhcmFtIEV4cHJlc3Npb24gJGV4cHJlc3Npb24gVGhlIGV4cHJlc3Npb24gdG8gaW5kZXgKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":454,"slug":"index-method-btree","name":"index_method_btree","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgQlRSRUUgaW5kZXggbWV0aG9kLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":463,"slug":"index-method-hash","name":"index_method_hash","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgSEFTSCBpbmRleCBtZXRob2QuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":472,"slug":"index-method-gist","name":"index_method_gist","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgR0lTVCBpbmRleCBtZXRob2QuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":481,"slug":"index-method-spgist","name":"index_method_spgist","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgU1BHSVNUIGluZGV4IG1ldGhvZC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":490,"slug":"index-method-gin","name":"index_method_gin","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgR0lOIGluZGV4IG1ldGhvZC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":499,"slug":"index-method-brin","name":"index_method_brin","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Index","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgQlJJTiBpbmRleCBtZXRob2QuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":511,"slug":"vacuum","name":"vacuum","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"VacuumFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZBQ1VVTSBidWlsZGVyLgogKgogKiBFeGFtcGxlOiB2YWN1dW0oKS0+dGFibGUoJ3VzZXJzJykKICogUHJvZHVjZXM6IFZBQ1VVTSB1c2VycwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":523,"slug":"analyze","name":"analyze","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AnalyzeFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBTkFMWVpFIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IGFuYWx5emUoKS0+dGFibGUoJ3VzZXJzJykKICogUHJvZHVjZXM6IEFOQUxZWkUgdXNlcnMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":537,"slug":"explain","name":"explain","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false},{"name":"InsertBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Insert","is_nullable":false,"is_variadic":false},{"name":"UpdateBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Update","is_nullable":false,"is_variadic":false},{"name":"DeleteBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Delete","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExplainFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFWFBMQUlOIGJ1aWxkZXIgZm9yIGEgcXVlcnkuCiAqCiAqIEV4YW1wbGU6IGV4cGxhaW4oc2VsZWN0KCktPmZyb20oJ3VzZXJzJykpCiAqIFByb2R1Y2VzOiBFWFBMQUlOIFNFTEVDVCAqIEZST00gdXNlcnMKICoKICogQHBhcmFtIERlbGV0ZUJ1aWxkZXJ8SW5zZXJ0QnVpbGRlcnxTZWxlY3RGaW5hbFN0ZXB8VXBkYXRlQnVpbGRlciAkcXVlcnkgUXVlcnkgdG8gZXhwbGFpbgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":549,"slug":"lock-table","name":"lock_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"LockFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExPQ0sgVEFCTEUgYnVpbGRlci4KICoKICogRXhhbXBsZTogbG9ja190YWJsZSgndXNlcnMnLCAnb3JkZXJzJyktPmFjY2Vzc0V4Y2x1c2l2ZSgpCiAqIFByb2R1Y2VzOiBMT0NLIFRBQkxFIHVzZXJzLCBvcmRlcnMgSU4gQUNDRVNTIEVYQ0xVU0lWRSBNT0RFCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":564,"slug":"comment","name":"comment","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"target","type":[{"name":"CommentTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CommentFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTU1FTlQgT04gYnVpbGRlci4KICoKICogRXhhbXBsZTogY29tbWVudChDb21tZW50VGFyZ2V0OjpUQUJMRSwgJ3VzZXJzJyktPmlzKCdVc2VyIGFjY291bnRzIHRhYmxlJykKICogUHJvZHVjZXM6IENPTU1FTlQgT04gVEFCTEUgdXNlcnMgSVMgJ1VzZXIgYWNjb3VudHMgdGFibGUnCiAqCiAqIEBwYXJhbSBDb21tZW50VGFyZ2V0ICR0YXJnZXQgVGFyZ2V0IHR5cGUgKFRBQkxFLCBDT0xVTU4sIElOREVYLCBldGMuKQogKiBAcGFyYW0gc3RyaW5nICRuYW1lIFRhcmdldCBuYW1lICh1c2UgJ3RhYmxlLmNvbHVtbicgZm9yIENPTFVNTiB0YXJnZXRzKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":576,"slug":"cluster","name":"cluster","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ClusterFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENMVVNURVIgYnVpbGRlci4KICoKICogRXhhbXBsZTogY2x1c3RlcigpLT50YWJsZSgndXNlcnMnKS0+dXNpbmcoJ2lkeF91c2Vyc19wa2V5JykKICogUHJvZHVjZXM6IENMVVNURVIgdXNlcnMgVVNJTkcgaWR4X3VzZXJzX3BrZXkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":590,"slug":"discard","name":"discard","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"type","type":[{"name":"DiscardType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DiscardFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERJU0NBUkQgYnVpbGRlci4KICoKICogRXhhbXBsZTogZGlzY2FyZChEaXNjYXJkVHlwZTo6QUxMKQogKiBQcm9kdWNlczogRElTQ0FSRCBBTEwKICoKICogQHBhcmFtIERpc2NhcmRUeXBlICR0eXBlIFR5cGUgb2YgcmVzb3VyY2VzIHRvIGRpc2NhcmQgKEFMTCwgUExBTlMsIFNFUVVFTkNFUywgVEVNUCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":609,"slug":"grant","name":"grant","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"privileges","type":[{"name":"TablePrivilege","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"GrantOnStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdSQU5UIHByaXZpbGVnZXMgYnVpbGRlci4KICoKICogRXhhbXBsZTogZ3JhbnQoVGFibGVQcml2aWxlZ2U6OlNFTEVDVCktPm9uVGFibGUoJ3VzZXJzJyktPnRvKCdhcHBfdXNlcicpCiAqIFByb2R1Y2VzOiBHUkFOVCBTRUxFQ1QgT04gdXNlcnMgVE8gYXBwX3VzZXIKICoKICogRXhhbXBsZTogZ3JhbnQoVGFibGVQcml2aWxlZ2U6OkFMTCktPm9uQWxsVGFibGVzSW5TY2hlbWEoJ3B1YmxpYycpLT50bygnYWRtaW4nKQogKiBQcm9kdWNlczogR1JBTlQgQUxMIE9OIEFMTCBUQUJMRVMgSU4gU0NIRU1BIHB1YmxpYyBUTyBhZG1pbgogKgogKiBAcGFyYW0gc3RyaW5nfFRhYmxlUHJpdmlsZWdlIC4uLiRwcml2aWxlZ2VzIFRoZSBwcml2aWxlZ2VzIHRvIGdyYW50CiAqCiAqIEByZXR1cm4gR3JhbnRPblN0ZXAgQnVpbGRlciBmb3IgZ3JhbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":628,"slug":"grant-role","name":"grant_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"GrantRoleToStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdSQU5UIHJvbGUgYnVpbGRlci4KICoKICogRXhhbXBsZTogZ3JhbnRfcm9sZSgnYWRtaW4nKS0+dG8oJ3VzZXIxJykKICogUHJvZHVjZXM6IEdSQU5UIGFkbWluIFRPIHVzZXIxCiAqCiAqIEV4YW1wbGU6IGdyYW50X3JvbGUoJ2FkbWluJywgJ2RldmVsb3BlcicpLT50bygndXNlcjEnKS0+d2l0aEFkbWluT3B0aW9uKCkKICogUHJvZHVjZXM6IEdSQU5UIGFkbWluLCBkZXZlbG9wZXIgVE8gdXNlcjEgV0lUSCBBRE1JTiBPUFRJT04KICoKICogQHBhcmFtIHN0cmluZyAuLi4kcm9sZXMgVGhlIHJvbGVzIHRvIGdyYW50CiAqCiAqIEByZXR1cm4gR3JhbnRSb2xlVG9TdGVwIEJ1aWxkZXIgZm9yIGdyYW50IHJvbGUgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":647,"slug":"revoke","name":"revoke","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"privileges","type":[{"name":"TablePrivilege","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"RevokeOnStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVk9LRSBwcml2aWxlZ2VzIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJldm9rZShUYWJsZVByaXZpbGVnZTo6U0VMRUNUKS0+b25UYWJsZSgndXNlcnMnKS0+ZnJvbSgnYXBwX3VzZXInKQogKiBQcm9kdWNlczogUkVWT0tFIFNFTEVDVCBPTiB1c2VycyBGUk9NIGFwcF91c2VyCiAqCiAqIEV4YW1wbGU6IHJldm9rZShUYWJsZVByaXZpbGVnZTo6QUxMKS0+b25UYWJsZSgndXNlcnMnKS0+ZnJvbSgnYXBwX3VzZXInKS0+Y2FzY2FkZSgpCiAqIFByb2R1Y2VzOiBSRVZPS0UgQUxMIE9OIHVzZXJzIEZST00gYXBwX3VzZXIgQ0FTQ0FERQogKgogKiBAcGFyYW0gc3RyaW5nfFRhYmxlUHJpdmlsZWdlIC4uLiRwcml2aWxlZ2VzIFRoZSBwcml2aWxlZ2VzIHRvIHJldm9rZQogKgogKiBAcmV0dXJuIFJldm9rZU9uU3RlcCBCdWlsZGVyIGZvciByZXZva2Ugb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":666,"slug":"revoke-role","name":"revoke_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"RevokeRoleFromStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Grant","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVk9LRSByb2xlIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJldm9rZV9yb2xlKCdhZG1pbicpLT5mcm9tKCd1c2VyMScpCiAqIFByb2R1Y2VzOiBSRVZPS0UgYWRtaW4gRlJPTSB1c2VyMQogKgogKiBFeGFtcGxlOiByZXZva2Vfcm9sZSgnYWRtaW4nKS0+ZnJvbSgndXNlcjEnKS0+Y2FzY2FkZSgpCiAqIFByb2R1Y2VzOiBSRVZPS0UgYWRtaW4gRlJPTSB1c2VyMSBDQVNDQURFCiAqCiAqIEBwYXJhbSBzdHJpbmcgLi4uJHJvbGVzIFRoZSByb2xlcyB0byByZXZva2UKICoKICogQHJldHVybiBSZXZva2VSb2xlRnJvbVN0ZXAgQnVpbGRlciBmb3IgcmV2b2tlIHJvbGUgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":682,"slug":"set-role","name":"set_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"role","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SetRoleFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Session","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBST0xFIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHNldF9yb2xlKCdhZG1pbicpCiAqIFByb2R1Y2VzOiBTRVQgUk9MRSBhZG1pbgogKgogKiBAcGFyYW0gc3RyaW5nICRyb2xlIFRoZSByb2xlIHRvIHNldAogKgogKiBAcmV0dXJuIFNldFJvbGVGaW5hbFN0ZXAgQnVpbGRlciBmb3Igc2V0IHJvbGUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":696,"slug":"reset-role","name":"reset_role","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ResetRoleFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Session","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFU0VUIFJPTEUgYnVpbGRlci4KICoKICogRXhhbXBsZTogcmVzZXRfcm9sZSgpCiAqIFByb2R1Y2VzOiBSRVNFVCBST0xFCiAqCiAqIEByZXR1cm4gUmVzZXRSb2xlRmluYWxTdGVwIEJ1aWxkZXIgZm9yIHJlc2V0IHJvbGUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":712,"slug":"reassign-owned","name":"reassign_owned","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ReassignOwnedToStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Ownership","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFQVNTSUdOIE9XTkVEIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJlYXNzaWduX293bmVkKCdvbGRfcm9sZScpLT50bygnbmV3X3JvbGUnKQogKiBQcm9kdWNlczogUkVBU1NJR04gT1dORUQgQlkgb2xkX3JvbGUgVE8gbmV3X3JvbGUKICoKICogQHBhcmFtIHN0cmluZyAuLi4kcm9sZXMgVGhlIHJvbGVzIHdob3NlIG93bmVkIG9iamVjdHMgc2hvdWxkIGJlIHJlYXNzaWduZWQKICoKICogQHJldHVybiBSZWFzc2lnbk93bmVkVG9TdGVwIEJ1aWxkZXIgZm9yIHJlYXNzaWduIG93bmVkIG9wdGlvbnMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":731,"slug":"drop-owned","name":"drop_owned","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"roles","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"DropOwnedFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Ownership","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIERST1AgT1dORUQgYnVpbGRlci4KICoKICogRXhhbXBsZTogZHJvcF9vd25lZCgncm9sZTEnKQogKiBQcm9kdWNlczogRFJPUCBPV05FRCBCWSByb2xlMQogKgogKiBFeGFtcGxlOiBkcm9wX293bmVkKCdyb2xlMScsICdyb2xlMicpLT5jYXNjYWRlKCkKICogUHJvZHVjZXM6IERST1AgT1dORUQgQlkgcm9sZTEsIHJvbGUyIENBU0NBREUKICoKICogQHBhcmFtIHN0cmluZyAuLi4kcm9sZXMgVGhlIHJvbGVzIHdob3NlIG93bmVkIG9iamVjdHMgc2hvdWxkIGJlIGRyb3BwZWQKICoKICogQHJldHVybiBEcm9wT3duZWRGaW5hbFN0ZXAgQnVpbGRlciBmb3IgZHJvcCBvd25lZCBvcHRpb25zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":749,"slug":"func-arg","name":"func_arg","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FunctionArgument","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSBuZXcgZnVuY3Rpb24gYXJndW1lbnQgZm9yIHVzZSBpbiBmdW5jdGlvbi9wcm9jZWR1cmUgZGVmaW5pdGlvbnMuCiAqCiAqIEV4YW1wbGU6IGZ1bmNfYXJnKGNvbHVtbl90eXBlX2ludGVnZXIoKSkKICogRXhhbXBsZTogZnVuY19hcmcoY29sdW1uX3R5cGVfdGV4dCgpKS0+bmFtZWQoJ3VzZXJuYW1lJykKICogRXhhbXBsZTogZnVuY19hcmcoY29sdW1uX3R5cGVfaW50ZWdlcigpKS0+bmFtZWQoJ2NvdW50JyktPmRlZmF1bHQoJzAnKQogKiBFeGFtcGxlOiBmdW5jX2FyZyhjb2x1bW5fdHlwZV90ZXh0KCkpLT5vdXQoKQogKgogKiBAcGFyYW0gQ29sdW1uVHlwZSAkdHlwZSBUaGUgUG9zdGdyZVNRTCBkYXRhIHR5cGUgZm9yIHRoZSBhcmd1bWVudAogKgogKiBAcmV0dXJuIEZ1bmN0aW9uQXJndW1lbnQgQnVpbGRlciBmb3IgZnVuY3Rpb24gYXJndW1lbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":768,"slug":"call","name":"call","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"procedure","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CallFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSBDQUxMIHN0YXRlbWVudCBidWlsZGVyIGZvciBpbnZva2luZyBhIHByb2NlZHVyZS4KICoKICogRXhhbXBsZTogY2FsbCgndXBkYXRlX3N0YXRzJyktPndpdGgoMTIzKQogKiBQcm9kdWNlczogQ0FMTCB1cGRhdGVfc3RhdHMoMTIzKQogKgogKiBFeGFtcGxlOiBjYWxsKCdwcm9jZXNzX2RhdGEnKS0+d2l0aCgndGVzdCcsIDQyLCB0cnVlKQogKiBQcm9kdWNlczogQ0FMTCBwcm9jZXNzX2RhdGEoJ3Rlc3QnLCA0MiwgdHJ1ZSkKICoKICogQHBhcmFtIHN0cmluZyAkcHJvY2VkdXJlIFRoZSBuYW1lIG9mIHRoZSBwcm9jZWR1cmUgdG8gY2FsbAogKgogKiBAcmV0dXJuIENhbGxGaW5hbFN0ZXAgQnVpbGRlciBmb3IgY2FsbCBzdGF0ZW1lbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":787,"slug":"do-block","name":"do_block","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"code","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DoFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Function","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSBETyBzdGF0ZW1lbnQgYnVpbGRlciBmb3IgZXhlY3V0aW5nIGFuIGFub255bW91cyBjb2RlIGJsb2NrLgogKgogKiBFeGFtcGxlOiBkb19ibG9jaygnQkVHSU4gUkFJU0UgTk9USUNFICQkSGVsbG8gV29ybGQkJDsgRU5EOycpCiAqIFByb2R1Y2VzOiBETyAkJCBCRUdJTiBSQUlTRSBOT1RJQ0UgJCRIZWxsbyBXb3JsZCQkOyBFTkQ7ICQkIExBTkdVQUdFIHBscGdzcWwKICoKICogRXhhbXBsZTogZG9fYmxvY2soJ1NFTEVDVCAxJyktPmxhbmd1YWdlKCdzcWwnKQogKiBQcm9kdWNlczogRE8gJCQgU0VMRUNUIDEgJCQgTEFOR1VBR0Ugc3FsCiAqCiAqIEBwYXJhbSBzdHJpbmcgJGNvZGUgVGhlIGFub255bW91cyBjb2RlIGJsb2NrIHRvIGV4ZWN1dGUKICoKICogQHJldHVybiBEb0ZpbmFsU3RlcCBCdWlsZGVyIGZvciBETyBzdGF0ZW1lbnQgb3B0aW9ucwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":807,"slug":"type-attr","name":"type_attr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TypeAttribute","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema\\Type","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZXMgYSB0eXBlIGF0dHJpYnV0ZSBmb3IgY29tcG9zaXRlIHR5cGVzLgogKgogKiBFeGFtcGxlOiB0eXBlX2F0dHIoJ25hbWUnLCBjb2x1bW5fdHlwZV90ZXh0KCkpCiAqIFByb2R1Y2VzOiBuYW1lIHRleHQKICoKICogRXhhbXBsZTogdHlwZV9hdHRyKCdkZXNjcmlwdGlvbicsIGNvbHVtbl90eXBlX3RleHQoKSktPmNvbGxhdGUoJ2VuX1VTJykKICogUHJvZHVjZXM6IGRlc2NyaXB0aW9uIHRleHQgQ09MTEFURSAiZW5fVVMiCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGhlIGF0dHJpYnV0ZSBuYW1lCiAqIEBwYXJhbSBDb2x1bW5UeXBlICR0eXBlIFRoZSBhdHRyaWJ1dGUgdHlwZQogKgogKiBAcmV0dXJuIFR5cGVBdHRyaWJ1dGUgVHlwZSBhdHRyaWJ1dGUgdmFsdWUgb2JqZWN0CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":816,"slug":"column-type-integer","name":"column_type_integer","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbnRlZ2VyIGRhdGEgdHlwZSAoUG9zdGdyZVNRTCBpbnQ0KS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":825,"slug":"column-type-smallint","name":"column_type_smallint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNtYWxsaW50IGRhdGEgdHlwZSAoUG9zdGdyZVNRTCBpbnQyKS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":834,"slug":"column-type-bigint","name":"column_type_bigint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJpZ2ludCBkYXRhIHR5cGUgKFBvc3RncmVTUUwgaW50OCkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":843,"slug":"column-type-boolean","name":"column_type_boolean","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJvb2xlYW4gZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":852,"slug":"column-type-text","name":"column_type_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRleHQgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":861,"slug":"column-type-varchar","name":"column_type_varchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHZhcmNoYXIgZGF0YSB0eXBlIHdpdGggbGVuZ3RoIGNvbnN0cmFpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":870,"slug":"column-type-char","name":"column_type_char","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNoYXIgZGF0YSB0eXBlIHdpdGggbGVuZ3RoIGNvbnN0cmFpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":879,"slug":"column-type-numeric","name":"column_type_numeric","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG51bWVyaWMgZGF0YSB0eXBlIHdpdGggb3B0aW9uYWwgcHJlY2lzaW9uIGFuZCBzY2FsZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":888,"slug":"column-type-decimal","name":"column_type_decimal","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRlY2ltYWwgZGF0YSB0eXBlIHdpdGggb3B0aW9uYWwgcHJlY2lzaW9uIGFuZCBzY2FsZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":897,"slug":"column-type-real","name":"column_type_real","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJlYWwgZGF0YSB0eXBlIChQb3N0Z3JlU1FMIGZsb2F0NCkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":906,"slug":"column-type-double-precision","name":"column_type_double_precision","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRvdWJsZSBwcmVjaXNpb24gZGF0YSB0eXBlIChQb3N0Z3JlU1FMIGZsb2F0OCkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":915,"slug":"column-type-date","name":"column_type_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRhdGUgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":924,"slug":"column-type-time","name":"column_type_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRpbWUgZGF0YSB0eXBlIHdpdGggb3B0aW9uYWwgcHJlY2lzaW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":933,"slug":"column-type-timestamp","name":"column_type_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRpbWVzdGFtcCBkYXRhIHR5cGUgd2l0aCBvcHRpb25hbCBwcmVjaXNpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":942,"slug":"column-type-timestamptz","name":"column_type_timestamptz","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRpbWVzdGFtcCB3aXRoIHRpbWUgem9uZSBkYXRhIHR5cGUgd2l0aCBvcHRpb25hbCBwcmVjaXNpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":951,"slug":"column-type-interval","name":"column_type_interval","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbnRlcnZhbCBkYXRhIHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":960,"slug":"column-type-uuid","name":"column_type_uuid","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFVVSUQgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":969,"slug":"column-type-json","name":"column_type_json","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":978,"slug":"column-type-jsonb","name":"column_type_jsonb","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":987,"slug":"column-type-bytea","name":"column_type_bytea","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJ5dGVhIGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":996,"slug":"column-type-xml","name":"column_type_xml","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBYTUwgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1005,"slug":"column-type-inet","name":"column_type_inet","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBpbmV0IGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1014,"slug":"column-type-cidr","name":"column_type_cidr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNpZHIgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1023,"slug":"column-type-macaddr","name":"column_type_macaddr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG1hY2FkZHIgZGF0YSB0eXBlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1032,"slug":"column-type-serial","name":"column_type_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNlcmlhbCBkYXRhIHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1041,"slug":"column-type-smallserial","name":"column_type_smallserial","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNtYWxsc2VyaWFsIGRhdGEgdHlwZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1050,"slug":"column-type-bigserial","name":"column_type_bigserial","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJpZ3NlcmlhbCBkYXRhIHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1059,"slug":"column-type-array","name":"column_type_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"elementType","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBkYXRhIHR5cGUgZnJvbSBhbiBlbGVtZW50IHR5cGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1071,"slug":"column-type-custom","name":"column_type_custom","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"typeName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGN1c3RvbSBkYXRhIHR5cGUuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJHR5cGVOYW1lIFR5cGUgbmFtZQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNjaGVtYSBPcHRpb25hbCBzY2hlbWEgbmFtZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1084,"slug":"column-type-from-string","name":"column_type_from_string","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"typeName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcnNlIGEgUG9zdGdyZVNRTCB0eXBlIHN0cmluZyBpbnRvIGEgQ29sdW1uVHlwZS4KICoKICogSGFuZGxlcyBhbGwgUG9zdGdyZVNRTCB0eXBlIHN5bnRheCBpbmNsdWRpbmcgcHJlY2lzaW9uLCBhcnJheXMsIGFuZCBzY2hlbWEtcXVhbGlmaWVkIHR5cGVzLgogKgogKiBAcGFyYW0gc3RyaW5nICR0eXBlTmFtZSBQb3N0Z3JlU1FMIHR5cGUgc3RyaW5nIChlLmcuLCAnaW50ZWdlcicsICdjaGFyYWN0ZXIgdmFyeWluZygyNTUpJywgJ3RleHRbXScpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1092,"slug":"value-type-text","name":"value_type_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1098,"slug":"value-type-varchar","name":"value_type_varchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1104,"slug":"value-type-char","name":"value_type_char","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1110,"slug":"value-type-bpchar","name":"value_type_bpchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1116,"slug":"value-type-int2","name":"value_type_int2","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1122,"slug":"value-type-smallint","name":"value_type_smallint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1128,"slug":"value-type-int4","name":"value_type_int4","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1134,"slug":"value-type-integer","name":"value_type_integer","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1140,"slug":"value-type-int8","name":"value_type_int8","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1146,"slug":"value-type-bigint","name":"value_type_bigint","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1152,"slug":"value-type-float4","name":"value_type_float4","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1158,"slug":"value-type-real","name":"value_type_real","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1164,"slug":"value-type-float8","name":"value_type_float8","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1170,"slug":"value-type-double","name":"value_type_double","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1176,"slug":"value-type-numeric","name":"value_type_numeric","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1182,"slug":"value-type-money","name":"value_type_money","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1188,"slug":"value-type-bool","name":"value_type_bool","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1194,"slug":"value-type-boolean","name":"value_type_boolean","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1200,"slug":"value-type-bytea","name":"value_type_bytea","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1206,"slug":"value-type-bit","name":"value_type_bit","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1212,"slug":"value-type-varbit","name":"value_type_varbit","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1218,"slug":"value-type-date","name":"value_type_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1224,"slug":"value-type-time","name":"value_type_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1230,"slug":"value-type-timetz","name":"value_type_timetz","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1236,"slug":"value-type-timestamp","name":"value_type_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1242,"slug":"value-type-timestamptz","name":"value_type_timestamptz","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1248,"slug":"value-type-interval","name":"value_type_interval","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1254,"slug":"value-type-json","name":"value_type_json","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1260,"slug":"value-type-jsonb","name":"value_type_jsonb","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1266,"slug":"value-type-uuid","name":"value_type_uuid","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1272,"slug":"value-type-inet","name":"value_type_inet","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1278,"slug":"value-type-cidr","name":"value_type_cidr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1284,"slug":"value-type-macaddr","name":"value_type_macaddr","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1290,"slug":"value-type-macaddr8","name":"value_type_macaddr8","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1296,"slug":"value-type-xml","name":"value_type_xml","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1302,"slug":"value-type-oid","name":"value_type_oid","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1308,"slug":"value-type-text-array","name":"value_type_text_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1314,"slug":"value-type-varchar-array","name":"value_type_varchar_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1320,"slug":"value-type-int2-array","name":"value_type_int2_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1326,"slug":"value-type-int4-array","name":"value_type_int4_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1332,"slug":"value-type-int8-array","name":"value_type_int8_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1338,"slug":"value-type-float4-array","name":"value_type_float4_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1344,"slug":"value-type-float8-array","name":"value_type_float8_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1350,"slug":"value-type-bool-array","name":"value_type_bool_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1356,"slug":"value-type-uuid-array","name":"value_type_uuid_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1362,"slug":"value-type-json-array","name":"value_type_json_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1368,"slug":"value-type-jsonb-array","name":"value_type_jsonb_array","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1384,"slug":"schema","name":"schema","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"sequences","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"views","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"materializedViews","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"functions","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"procedures","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"domains","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"extensions","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Schema","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVRhYmxlPiAkdGFibGVzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVNlcXVlbmNlPiAkc2VxdWVuY2VzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVZpZXc+ICR2aWV3cwogKiBAcGFyYW0gbGlzdDxTY2hlbWFNYXRlcmlhbGl6ZWRWaWV3PiAkbWF0ZXJpYWxpemVkVmlld3MKICogQHBhcmFtIGxpc3Q8U2NoZW1hRnVuY3Rpb24+ICRmdW5jdGlvbnMKICogQHBhcmFtIGxpc3Q8U2NoZW1hUHJvY2VkdXJlPiAkcHJvY2VkdXJlcwogKiBAcGFyYW0gbGlzdDxTY2hlbWFEb21haW4+ICRkb21haW5zCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUV4dGVuc2lvbj4gJGV4dGVuc2lvbnMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1420,"slug":"schema-table","name":"schema_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"primaryKey","type":[{"name":"PrimaryKey","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"indexes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"foreignKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"uniqueConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"checkConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"excludeConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"triggers","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'public'"},{"name":"unlogged","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"partitionStrategy","type":[{"name":"PartitionStrategy","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"partitionColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"inherits","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"tablespace","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Table","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxTY2hlbWFDb2x1bW4+ICRjb2x1bW5zCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUluZGV4PiAkaW5kZXhlcwogKiBAcGFyYW0gbGlzdDxTY2hlbWFGb3JlaWduS2V5PiAkZm9yZWlnbktleXMKICogQHBhcmFtIGxpc3Q8U2NoZW1hVW5pcXVlQ29uc3RyYWludD4gJHVuaXF1ZUNvbnN0cmFpbnRzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUNoZWNrQ29uc3RyYWludD4gJGNoZWNrQ29uc3RyYWludHMKICogQHBhcmFtIGxpc3Q8U2NoZW1hRXhjbHVkZUNvbnN0cmFpbnQ+ICRleGNsdWRlQ29uc3RyYWludHMKICogQHBhcmFtIGxpc3Q8U2NoZW1hVHJpZ2dlcj4gJHRyaWdnZXJzCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHBhcnRpdGlvbkNvbHVtbnMKICogQHBhcmFtIGxpc3Q8c3RyaW5nPiAkaW5oZXJpdHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1465,"slug":"schema-table-options","name":"schema_table_options","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"foreignKeys","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"checkConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"excludeConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"triggers","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"unlogged","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"partitionStrategy","type":[{"name":"PartitionStrategy","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"partitionColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"inherits","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"tablespace","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TableOptions","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUZvcmVpZ25LZXk+ICRmb3JlaWduS2V5cwogKiBAcGFyYW0gbGlzdDxTY2hlbWFDaGVja0NvbnN0cmFpbnQ+ICRjaGVja0NvbnN0cmFpbnRzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUV4Y2x1ZGVDb25zdHJhaW50PiAkZXhjbHVkZUNvbnN0cmFpbnRzCiAqIEBwYXJhbSBsaXN0PFNjaGVtYVRyaWdnZXI+ICR0cmlnZ2VycwogKiBAcGFyYW0gbGlzdDxzdHJpbmc+ICRwYXJ0aXRpb25Db2x1bW5zCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGluaGVyaXRzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1490,"slug":"schema-column","name":"schema_column","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"isIdentity","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"identityGeneration","type":[{"name":"IdentityGeneration","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"isGenerated","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"generationExpression","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"ordinalPosition","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1515,"slug":"schema-column-integer","name":"schema_column_integer","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1524,"slug":"schema-column-smallint","name":"schema_column_smallint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1533,"slug":"schema-column-bigint","name":"schema_column_bigint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1542,"slug":"schema-column-serial","name":"schema_column_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1548,"slug":"schema-column-small-serial","name":"schema_column_small_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1554,"slug":"schema-column-big-serial","name":"schema_column_big_serial","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1560,"slug":"schema-column-boolean","name":"schema_column_boolean","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1569,"slug":"schema-column-text","name":"schema_column_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1578,"slug":"schema-column-varchar","name":"schema_column_varchar","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1588,"slug":"schema-column-char","name":"schema_column_char","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"length","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1598,"slug":"schema-column-numeric","name":"schema_column_numeric","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"scale","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1609,"slug":"schema-column-real","name":"schema_column_real","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1618,"slug":"schema-column-double-precision","name":"schema_column_double_precision","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1627,"slug":"schema-column-date","name":"schema_column_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1636,"slug":"schema-column-time","name":"schema_column_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1646,"slug":"schema-column-timestamp","name":"schema_column_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1656,"slug":"schema-column-timestamp-tz","name":"schema_column_timestamp_tz","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"precision","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1666,"slug":"schema-column-interval","name":"schema_column_interval","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1675,"slug":"schema-column-uuid","name":"schema_column_uuid","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1684,"slug":"schema-column-json","name":"schema_column_json","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1693,"slug":"schema-column-jsonb","name":"schema_column_jsonb","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1702,"slug":"schema-column-bytea","name":"schema_column_bytea","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1711,"slug":"schema-column-inet","name":"schema_column_inet","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1720,"slug":"schema-column-cidr","name":"schema_column_cidr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1729,"slug":"schema-column-macaddr","name":"schema_column_macaddr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1741,"slug":"schema-primary-key","name":"schema_primary_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PrimaryKey","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1751,"slug":"schema-foreign-key","name":"schema_foreign_key","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceTable","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"referenceColumns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"referenceSchema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'public'"},{"name":"onUpdate","type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Schema\\ReferentialAction::..."},{"name":"onDelete","type":[{"name":"ReferentialAction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Schema\\ReferentialAction::..."},{"name":"deferrable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"initiallyDeferred","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"ForeignKey","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRyZWZlcmVuY2VDb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1779,"slug":"schema-unique","name":"schema_unique","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"nullsNotDistinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"UniqueConstraint","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1785,"slug":"schema-check","name":"schema_check","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expression","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"noInherit","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"CheckConstraint","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1791,"slug":"schema-exclude","name":"schema_exclude","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ExcludeConstraint","namespace":"Flow\\PostgreSql\\Schema\\Constraint","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1800,"slug":"schema-index","name":"schema_index","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"unique","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"method","type":[{"name":"IndexMethod","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\Schema\\IndexMethod::..."},{"name":"primary","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"predicate","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Index","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxzdHJpbmc+ICRjb2x1bW5zCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1812,"slug":"schema-sequence","name":"schema_sequence","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"dataType","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'bigint'"},{"name":"startValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"minValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"maxValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"incrementBy","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"cycle","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"cacheValue","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"ownedByTable","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"ownedByColumn","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Sequence","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1839,"slug":"schema-view","name":"schema_view","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"isUpdatable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"View","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1848,"slug":"schema-materialized-view","name":"schema_materialized_view","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"indexes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"MaterializedView","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUluZGV4PiAkaW5kZXhlcwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1857,"slug":"schema-function","name":"schema_function","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"returnType","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"argumentTypes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"language","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'sql'"},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"isStrict","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"volatility","type":[{"name":"FunctionVolatility","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Func","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGFyZ3VtZW50VHlwZXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1873,"slug":"schema-procedure","name":"schema_procedure","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"argumentTypes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"language","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'sql'"},{"name":"definition","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Procedure","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJGFyZ3VtZW50VHlwZXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1886,"slug":"schema-trigger","name":"schema_trigger","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tableName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"timing","type":[{"name":"TriggerTiming","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"events","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"functionName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"forEachRow","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"whenCondition","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Trigger","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBub24tZW1wdHktbGlzdDxUcmlnZ2VyRXZlbnQ+ICRldmVudHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1902,"slug":"schema-domain","name":"schema_domain","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"baseType","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nullable","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"default","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"checkConstraints","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Domain","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBsaXN0PFNjaGVtYUNoZWNrQ29uc3RyYWludD4gJGNoZWNrQ29uc3RyYWludHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1913,"slug":"schema-extension","name":"schema_extension","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"version","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Extension","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1922,"slug":"client-catalog-provider","name":"client_catalog_provider","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schemaNames","type":[{"name":"array","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"exclusionPolicy","type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSA\/bGlzdDxzdHJpbmc+ICRzY2hlbWFOYW1lcwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1931,"slug":"exclude-any","name":"exclude_any","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"policies","type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1937,"slug":"exclude-exact","name":"exclude_exact","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1943,"slug":"exclude-starts-with","name":"exclude_starts_with","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"prefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1949,"slug":"exclude-ends-with","name":"exclude_ends_with","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"suffix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1955,"slug":"exclude-pattern","name":"exclude_pattern","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"pattern","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1961,"slug":"exclude-schema","name":"exclude_schema","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1967,"slug":"exclude-scoped","name":"exclude_scoped","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"policy","type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"type","type":[{"name":"SchemaObjectType","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"ExclusionPolicy","namespace":"Flow\\PostgreSql\\Schema\\Exclusion","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1976,"slug":"manual-catalog-provider","name":"manual_catalog_provider","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"catalog","type":[{"name":"Catalog","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"CatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1982,"slug":"chain-catalog-provider","name":"chain_catalog_provider","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"providers","type":[{"name":"CatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ChainCatalogProvider","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":1991,"slug":"catalog-comparator","name":"catalog_comparator","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"renameStrategy","type":[{"name":"RenameStrategy","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"viewDependencyResolver","type":[{"name":"ViewDependencyResolver","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"tableOrderStrategy","type":[{"name":"ExecutionOrderStrategy","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"dropIfExists","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"CatalogComparator","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBudWxsfEV4ZWN1dGlvbk9yZGVyU3RyYXRlZ3k8XEZsb3dcUG9zdGdyZVNxbFxTY2hlbWFcVGFibGU+ICR0YWJsZU9yZGVyU3RyYXRlZ3kKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2006,"slug":"ast-view-dependency-resolver","name":"ast_view_dependency_resolver","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AstViewDependencyResolver","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2012,"slug":"noop-view-dependency-resolver","name":"noop_view_dependency_resolver","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"NoopViewDependencyResolver","namespace":"Flow\\PostgreSql\\Schema\\Diff","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2018,"slug":"foreign-key-dependency-order","name":"foreign_key_dependency_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ForeignKeyDependencyOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2027,"slug":"no-execution-order","name":"no_execution_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"NoExecutionOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gTm9FeGVjdXRpb25PcmRlcjxtaXhlZD4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2033,"slug":"view-dependency-order","name":"view_dependency_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ViewDependencyOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/schema.php","start_line_in_file":2039,"slug":"materialized-view-dependency-order","name":"materialized_view_dependency_order","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"MaterializedViewDependencyOrder","namespace":"Flow\\PostgreSql\\Schema","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":117,"slug":"select","name":"select","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"SelectBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBTRUxFQ1QgcXVlcnkgYnVpbGRlci4KICoKICogQHBhcmFtIEV4cHJlc3Npb258c3RyaW5nIC4uLiRleHByZXNzaW9ucyBDb2x1bW5zIHRvIHNlbGVjdC4gSWYgZW1wdHksIHJldHVybnMgU2VsZWN0U2VsZWN0U3RlcC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":134,"slug":"parsed-select","name":"parsed_select","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ParsedSelect","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNlbGVjdEZpbmFsU3RlcCBmcm9tIGEgcmF3IFNRTCBTRUxFQ1Qgc3RyaW5nLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":146,"slug":"with","name":"with","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"ctes","type":[{"name":"CTE","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"WithBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\With","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFdJVEggY2xhdXNlIGJ1aWxkZXIgZm9yIENURXMuCiAqCiAqIEV4YW1wbGU6IHdpdGgoY3RlKCd1c2VycycsICRzdWJxdWVyeSkpLT5zZWxlY3Qoc3RhcigpKS0+ZnJvbSh0YWJsZSgndXNlcnMnKSkKICogRXhhbXBsZTogd2l0aChjdGUoJ2EnLCAkcTEpLCBjdGUoJ2InLCAkcTIpKS0+cmVjdXJzaXZlKCktPnNlbGVjdCguLi4pLT5mcm9tKHRhYmxlKCdhJykpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":159,"slug":"insert","name":"insert","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"InsertIntoStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Insert","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBJTlNFUlQgcXVlcnkgYnVpbGRlci4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":175,"slug":"bulk-insert","name":"bulk_insert","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"rowCount","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BulkInsert","namespace":"Flow\\PostgreSql\\QueryBuilder\\Insert","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBvcHRpbWl6ZWQgYnVsayBJTlNFUlQgcXVlcnkgZm9yIGhpZ2gtcGVyZm9ybWFuY2UgbXVsdGktcm93IGluc2VydHMuCiAqCiAqIFVubGlrZSBpbnNlcnQoKSB3aGljaCB1c2VzIGltbXV0YWJsZSBidWlsZGVyIHBhdHRlcm5zIChPKG7CsikgZm9yIG4gcm93cyksCiAqIHRoaXMgZnVuY3Rpb24gZ2VuZXJhdGVzIFNRTCBkaXJlY3RseSB1c2luZyBzdHJpbmcgb3BlcmF0aW9ucyAoTyhuKSBjb21wbGV4aXR5KS4KICoKICogQHBhcmFtIHN0cmluZyAkdGFibGUgVGFibGUgbmFtZQogKiBAcGFyYW0gbGlzdDxzdHJpbmc+ICRjb2x1bW5zIENvbHVtbiBuYW1lcwogKiBAcGFyYW0gaW50ICRyb3dDb3VudCBOdW1iZXIgb2Ygcm93cyB0byBpbnNlcnQKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":184,"slug":"update","name":"update","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"UpdateTableStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Update","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBVUERBVEUgcXVlcnkgYnVpbGRlci4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":193,"slug":"delete","name":"delete","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"DeleteFromStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Delete","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBERUxFVEUgcXVlcnkgYnVpbGRlci4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":205,"slug":"merge","name":"merge","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"alias","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MergeUsingStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Merge","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBNRVJHRSBxdWVyeSBidWlsZGVyLgogKgogKiBAcGFyYW0gc3RyaW5nICR0YWJsZSBUYXJnZXQgdGFibGUgbmFtZQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGFsaWFzIE9wdGlvbmFsIHRhYmxlIGFsaWFzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":219,"slug":"copy","name":"copy","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"CopyFactory","namespace":"Flow\\PostgreSql\\QueryBuilder\\Factory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBDT1BZIHF1ZXJ5IGJ1aWxkZXIgZm9yIGRhdGEgaW1wb3J0L2V4cG9ydC4KICoKICogVXNhZ2U6CiAqICAgY29weSgpLT5mcm9tKCd1c2VycycpLT5maWxlKCcvdG1wL3VzZXJzLmNzdicpLT5mb3JtYXQoQ29weUZvcm1hdDo6Q1NWKQogKiAgIGNvcHkoKS0+dG8oJ3VzZXJzJyktPmZpbGUoJy90bXAvdXNlcnMuY3N2JyktPmZvcm1hdChDb3B5Rm9ybWF0OjpDU1YpCiAqICAgY29weSgpLT50b1F1ZXJ5KHNlbGVjdCguLi4pKS0+ZmlsZSgnL3RtcC9kYXRhLmNzdicpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":231,"slug":"listen","name":"listen","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"channel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ListenFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Listen","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExJU1RFTiBzdGF0ZW1lbnQgdG8gc3Vic2NyaWJlIHRoZSBjdXJyZW50IHNlc3Npb24gdG8gYSBub3RpZmljYXRpb24gY2hhbm5lbC4KICoKICogVXNhZ2U6CiAqICAgbGlzdGVuKCdteV9jaGFubmVsJyktPnRvU3FsKCkgIC8vIExJU1RFTiBteV9jaGFubmVsCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":243,"slug":"unlisten","name":"unlisten","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"channel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"UnlistenFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Unlisten","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBVTkxJU1RFTiBzdGF0ZW1lbnQgdG8gdW5zdWJzY3JpYmUgdGhlIGN1cnJlbnQgc2Vzc2lvbiBmcm9tIGEgbm90aWZpY2F0aW9uIGNoYW5uZWwuCiAqCiAqIFVzYWdlOgogKiAgIHVubGlzdGVuKCdteV9jaGFubmVsJyktPnRvU3FsKCkgIC8vIFVOTElTVEVOIG15X2NoYW5uZWwKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":256,"slug":"notify","name":"notify","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"channel","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"NotifyFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Notify","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE5PVElGWSBzdGF0ZW1lbnQgdG8gc2VuZCBhIG5vdGlmaWNhdGlvbiBvbiBhIGNoYW5uZWwsIG9wdGlvbmFsbHkgd2l0aCBhIHBheWxvYWQuCiAqCiAqIFVzYWdlOgogKiAgIG5vdGlmeSgnbXlfY2hhbm5lbCcpLT50b1NxbCgpICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gTk9USUZZIG15X2NoYW5uZWwKICogICBub3RpZnkoJ215X2NoYW5uZWwnKS0+d2l0aFBheWxvYWQoJ2hlbGxvJyktPnRvU3FsKCkgICAgIC8vIE5PVElGWSBteV9jaGFubmVsLCAnaGVsbG8nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":277,"slug":"col","name":"col","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Column","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbHVtbiByZWZlcmVuY2UgZXhwcmVzc2lvbi4KICoKICogQ2FuIGJlIHVzZWQgaW4gdHdvIG1vZGVzOgogKiAtIFBhcnNlIG1vZGU6IGNvbCgndXNlcnMuaWQnKSBvciBjb2woJ3NjaGVtYS50YWJsZS5jb2x1bW4nKSAtIHBhcnNlcyBkb3Qtc2VwYXJhdGVkIHN0cmluZwogKiAtIEV4cGxpY2l0IG1vZGU6IGNvbCgnaWQnLCAndXNlcnMnKSBvciBjb2woJ2lkJywgJ3VzZXJzJywgJ3NjaGVtYScpIC0gc2VwYXJhdGUgYXJndW1lbnRzCiAqCiAqIFdoZW4gJHRhYmxlIG9yICRzY2hlbWEgaXMgcHJvdmlkZWQsICRjb2x1bW4gbXVzdCBiZSBhIHBsYWluIGNvbHVtbiBuYW1lIChubyBkb3RzKS4KICoKICogQHBhcmFtIHN0cmluZyAkY29sdW1uIENvbHVtbiBuYW1lLCBvciBkb3Qtc2VwYXJhdGVkIHBhdGggbGlrZSAidGFibGUuY29sdW1uIiBvciAic2NoZW1hLnRhYmxlLmNvbHVtbiIKICogQHBhcmFtIG51bGx8c3RyaW5nICR0YWJsZSBUYWJsZSBuYW1lIChvcHRpb25hbCwgdHJpZ2dlcnMgZXhwbGljaXQgbW9kZSkKICogQHBhcmFtIG51bGx8c3RyaW5nICRzY2hlbWEgU2NoZW1hIG5hbWUgKG9wdGlvbmFsLCByZXF1aXJlcyAkdGFibGUpCiAqCiAqIEB0aHJvd3MgSW52YWxpZEV4cHJlc3Npb25FeGNlcHRpb24gd2hlbiAkc2NoZW1hIGlzIHByb3ZpZGVkIHdpdGhvdXQgJHRhYmxlLCBvciB3aGVuICRjb2x1bW4gY29udGFpbnMgZG90cyBpbiBleHBsaWNpdCBtb2RlCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":304,"slug":"star","name":"star","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"table","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Star","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFTEVDVCAqIGV4cHJlc3Npb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":320,"slug":"literal","name":"literal","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"value","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Literal","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxpdGVyYWwgdmFsdWUgZm9yIHVzZSBpbiBxdWVyaWVzLgogKgogKiBBdXRvbWF0aWNhbGx5IGRldGVjdHMgdGhlIHR5cGUgYW5kIGNyZWF0ZXMgdGhlIGFwcHJvcHJpYXRlIGxpdGVyYWw6CiAqIC0gbGl0ZXJhbCgnaGVsbG8nKSBjcmVhdGVzIGEgc3RyaW5nIGxpdGVyYWwKICogLSBsaXRlcmFsKDQyKSBjcmVhdGVzIGFuIGludGVnZXIgbGl0ZXJhbAogKiAtIGxpdGVyYWwoMy4xNCkgY3JlYXRlcyBhIGZsb2F0IGxpdGVyYWwKICogLSBsaXRlcmFsKHRydWUpIGNyZWF0ZXMgYSBib29sZWFuIGxpdGVyYWwKICogLSBsaXRlcmFsKG51bGwpIGNyZWF0ZXMgYSBOVUxMIGxpdGVyYWwKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":335,"slug":"param","name":"param","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"position","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Parameter","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHBvc2l0aW9uYWwgcGFyYW1ldGVyICgkMSwgJDIsIGV0Yy4pLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":344,"slug":"parameters","name":"parameters","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"count","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"startAt","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"}],"return_type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEByZXR1cm4gbGlzdDxQYXJhbWV0ZXI+CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":370,"slug":"func","name":"func","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"FunctionCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZ1bmN0aW9uIGNhbGwgZXhwcmVzc2lvbi4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBGdW5jdGlvbiBuYW1lIChjYW4gaW5jbHVkZSBzY2hlbWEgbGlrZSAicGdfY2F0YWxvZy5ub3ciKQogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGFyZ3MgRnVuY3Rpb24gYXJndW1lbnRzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":404,"slug":"agg","name":"agg","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhZ2dyZWdhdGUgZnVuY3Rpb24gY2FsbCAoQ09VTlQsIFNVTSwgQVZHLCBldGMuKS4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBBZ2dyZWdhdGUgZnVuY3Rpb24gbmFtZQogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGFyZ3MgRnVuY3Rpb24gYXJndW1lbnRzCiAqIEBwYXJhbSBib29sICRkaXN0aW5jdCBVc2UgRElTVElOQ1QgbW9kaWZpZXIKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":418,"slug":"agg-count","name":"agg_count","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDT1VOVCgqKSBhZ2dyZWdhdGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":431,"slug":"count-all","name":"count_all","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDT1VOVCgqKSBhZ2dyZWdhdGUuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":440,"slug":"agg-sum","name":"agg_sum","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBTVU0gYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":449,"slug":"agg-avg","name":"agg_avg","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"distinct","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBBVkcgYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":458,"slug":"agg-min","name":"agg_min","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBNSU4gYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":467,"slug":"agg-max","name":"agg_max","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AggregateCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBNQVggYWdncmVnYXRlLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":478,"slug":"coalesce","name":"coalesce","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Coalesce","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPQUxFU0NFIGV4cHJlc3Npb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gY29hbGVzY2UKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":489,"slug":"nullif","name":"nullif","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr1","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"expr2","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"NullIf","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE5VTExJRiBleHByZXNzaW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":503,"slug":"greatest","name":"greatest","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Greatest","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdSRUFURVNUIGV4cHJlc3Npb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gY29tcGFyZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":516,"slug":"least","name":"least","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Least","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExFQVNUIGV4cHJlc3Npb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gY29tcGFyZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":530,"slug":"cast","name":"cast","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"dataType","type":[{"name":"ColumnType","namespace":"Flow\\PostgreSql\\QueryBuilder\\Schema","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TypeCast","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHR5cGUgY2FzdCBleHByZXNzaW9uLgogKgogKiBAcGFyYW0gRXhwcmVzc2lvbnxzdHJpbmcgJGV4cHIgRXhwcmVzc2lvbiB0byBjYXN0CiAqIEBwYXJhbSBDb2x1bW5UeXBlICRkYXRhVHlwZSBUYXJnZXQgZGF0YSB0eXBlICh1c2UgY29sdW1uX3R5cGVfKiBmdW5jdGlvbnMpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":542,"slug":"collate","name":"collate","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"collation","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Collate","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTExBVEUgZXhwcmVzc2lvbi4KICoKICogQHBhcmFtIEV4cHJlc3Npb258c3RyaW5nICRleHByIEV4cHJlc3Npb24gdG8gY29sbGF0ZQogKiBAcGFyYW0gc3RyaW5nICRjb2xsYXRpb24gQ29sbGF0aW9uIG5hbWUgYXMgd3JpdHRlbiBpbiBTUUw6ICdDJywgJyJkZV9ERSInLCAncGdfY2F0YWxvZy4iQyInCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":557,"slug":"current-timestamp","name":"current_timestamp","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SQLValueFunctionExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNRTCBzdGFuZGFyZCBDVVJSRU5UX1RJTUVTVEFNUCBmdW5jdGlvbi4KICoKICogUmV0dXJucyB0aGUgY3VycmVudCBkYXRlIGFuZCB0aW1lIChhdCB0aGUgc3RhcnQgb2YgdGhlIHRyYW5zYWN0aW9uKS4KICogVXNlZnVsIGFzIGEgY29sdW1uIGRlZmF1bHQgdmFsdWUgb3IgaW4gU0VMRUNUIHF1ZXJpZXMuCiAqCiAqIEV4YW1wbGU6IGNvbHVtbignY3JlYXRlZF9hdCcsIGNvbHVtbl90eXBlX3RpbWVzdGFtcCgpKS0+ZGVmYXVsdChjdXJyZW50X3RpbWVzdGFtcCgpKQogKiBFeGFtcGxlOiBzZWxlY3QoKS0+c2VsZWN0KGN1cnJlbnRfdGltZXN0YW1wKCktPmFzKCdub3cnKSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":572,"slug":"current-date","name":"current_date","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SQLValueFunctionExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNRTCBzdGFuZGFyZCBDVVJSRU5UX0RBVEUgZnVuY3Rpb24uCiAqCiAqIFJldHVybnMgdGhlIGN1cnJlbnQgZGF0ZSAoYXQgdGhlIHN0YXJ0IG9mIHRoZSB0cmFuc2FjdGlvbikuCiAqIFVzZWZ1bCBhcyBhIGNvbHVtbiBkZWZhdWx0IHZhbHVlIG9yIGluIFNFTEVDVCBxdWVyaWVzLgogKgogKiBFeGFtcGxlOiBjb2x1bW4oJ2JpcnRoX2RhdGUnLCBjb2x1bW5fdHlwZV9kYXRlKCkpLT5kZWZhdWx0KGN1cnJlbnRfZGF0ZSgpKQogKiBFeGFtcGxlOiBzZWxlY3QoKS0+c2VsZWN0KGN1cnJlbnRfZGF0ZSgpLT5hcygndG9kYXknKSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":587,"slug":"current-time","name":"current_time","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SQLValueFunctionExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNRTCBzdGFuZGFyZCBDVVJSRU5UX1RJTUUgZnVuY3Rpb24uCiAqCiAqIFJldHVybnMgdGhlIGN1cnJlbnQgdGltZSAoYXQgdGhlIHN0YXJ0IG9mIHRoZSB0cmFuc2FjdGlvbikuCiAqIFVzZWZ1bCBhcyBhIGNvbHVtbiBkZWZhdWx0IHZhbHVlIG9yIGluIFNFTEVDVCBxdWVyaWVzLgogKgogKiBFeGFtcGxlOiBjb2x1bW4oJ3N0YXJ0X3RpbWUnLCBjb2x1bW5fdHlwZV90aW1lKCkpLT5kZWZhdWx0KGN1cnJlbnRfdGltZSgpKQogKiBFeGFtcGxlOiBzZWxlY3QoKS0+c2VsZWN0KGN1cnJlbnRfdGltZSgpLT5hcygnbm93X3RpbWUnKSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":600,"slug":"case-when","name":"case_when","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"whenClauses","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"elseResult","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"operand","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"null","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CaseExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENBU0UgZXhwcmVzc2lvbi4KICoKICogQHBhcmFtIG5vbi1lbXB0eS1saXN0PFdoZW5DbGF1c2U+ICR3aGVuQ2xhdXNlcyBXSEVOIGNsYXVzZXMKICogQHBhcmFtIG51bGx8RXhwcmVzc2lvbnxzdHJpbmcgJGVsc2VSZXN1bHQgRUxTRSByZXN1bHQgKG9wdGlvbmFsKQogKiBAcGFyYW0gbnVsbHxFeHByZXNzaW9ufHN0cmluZyAkb3BlcmFuZCBDQVNFIG9wZXJhbmQgZm9yIHNpbXBsZSBDQVNFIChvcHRpb25hbCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":616,"slug":"when","name":"when","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"condition","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"result","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"WhenClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFdIRU4gY2xhdXNlIGZvciBDQVNFIGV4cHJlc3Npb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":628,"slug":"sub-select","name":"sub_select","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Subquery","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHN1YnF1ZXJ5IGV4cHJlc3Npb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":642,"slug":"array-expr","name":"array_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ArrayExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBleHByZXNzaW9uLgogKgogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGVsZW1lbnRzIEFycmF5IGVsZW1lbnRzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":655,"slug":"row-expr","name":"row_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"elements","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RowExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJvdyBleHByZXNzaW9uLgogKgogKiBAcGFyYW0gbGlzdDxFeHByZXNzaW9ufHN0cmluZz4gJGVsZW1lbnRzIFJvdyBlbGVtZW50cwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":666,"slug":"binary-expr","name":"binary_expr","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"operator","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGJpbmFyeSBleHByZXNzaW9uIChsZWZ0IG9wIHJpZ2h0KS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":684,"slug":"window-func","name":"window_func","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"args","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"partitionBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"orderBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"WindowFunction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHdpbmRvdyBmdW5jdGlvbi4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBGdW5jdGlvbiBuYW1lCiAqIEBwYXJhbSBsaXN0PEV4cHJlc3Npb258c3RyaW5nPiAkYXJncyBGdW5jdGlvbiBhcmd1bWVudHMKICogQHBhcmFtIGxpc3Q8RXhwcmVzc2lvbnxzdHJpbmc+ICRwYXJ0aXRpb25CeSBQQVJUSVRJT04gQlkgZXhwcmVzc2lvbnMKICogQHBhcmFtIGxpc3Q8T3JkZXJCeT4gJG9yZGVyQnkgT1JERVIgQlkgaXRlbXMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":705,"slug":"concat","name":"concat","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbmNhdGVuYXRlIGV4cHJlc3Npb25zIHdpdGggdGhlIHx8IG9wZXJhdG9yLgogKgogKiBFeGFtcGxlOiBjb25jYXQoY29sKCdzY2hlbWEnKSwgbGl0ZXJhbCgnLicpLCBjb2woJ3RhYmxlJykpCiAqIFByb2R1Y2VzOiBzY2hlbWEgfHwgJy4nIHx8IHRhYmxlCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgQXQgbGVhc3QgMiBleHByZXNzaW9ucyB0byBjb25jYXRlbmF0ZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":735,"slug":"table","name":"table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"schema","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Table","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRhYmxlIHJlZmVyZW5jZS4KICoKICogU3VwcG9ydHMgZG90IG5vdGF0aW9uIGZvciBzY2hlbWEtcXVhbGlmaWVkIG5hbWVzOiAicHVibGljLnVzZXJzIiBvciBleHBsaWNpdCBzY2hlbWEgcGFyYW1ldGVyLgogKiBEb3VibGUtcXVvdGVkIGlkZW50aWZpZXJzIHByZXNlcnZlIGRvdHM6ICcibXkudGFibGUiJyBjcmVhdGVzIGEgc2luZ2xlIGlkZW50aWZpZXIuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJG5hbWUgVGFibGUgbmFtZSAobWF5IGluY2x1ZGUgc2NoZW1hIGFzICJzY2hlbWEudGFibGUiKQogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHNjaGVtYSBTY2hlbWEgbmFtZSAob3B0aW9uYWwsIG92ZXJyaWRlcyBwYXJzZWQgc2NoZW1hKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":750,"slug":"derived","name":"derived","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"alias","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DerivedTable","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGRlcml2ZWQgdGFibGUgKHN1YnF1ZXJ5IGluIEZST00gY2xhdXNlKS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":764,"slug":"lateral","name":"lateral","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"reference","type":[{"name":"TableReference","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Lateral","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExBVEVSQUwgc3VicXVlcnkuCiAqCiAqIEBwYXJhbSBUYWJsZVJlZmVyZW5jZSAkcmVmZXJlbmNlIFRoZSBzdWJxdWVyeSBvciB0YWJsZSBmdW5jdGlvbiByZWZlcmVuY2UKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":776,"slug":"table-func","name":"table_func","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"function","type":[{"name":"FunctionCall","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"withOrdinality","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"TableFunction","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRhYmxlIGZ1bmN0aW9uIHJlZmVyZW5jZS4KICoKICogQHBhcmFtIEZ1bmN0aW9uQ2FsbCAkZnVuY3Rpb24gVGhlIHRhYmxlLXZhbHVlZCBmdW5jdGlvbgogKiBAcGFyYW0gYm9vbCAkd2l0aE9yZGluYWxpdHkgV2hldGhlciB0byBhZGQgV0lUSCBPUkRJTkFMSVRZCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":795,"slug":"values-table","name":"values_table","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"rows","type":[{"name":"RowExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ValuesTable","namespace":"Flow\\PostgreSql\\QueryBuilder\\Table","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZBTFVFUyBjbGF1c2UgYXMgYSB0YWJsZSByZWZlcmVuY2UuCiAqCiAqIFVzYWdlOgogKiAgIHNlbGVjdCgpLT5mcm9tKAogKiAgICAgICB2YWx1ZXNfdGFibGUoCiAqICAgICAgICAgICByb3dfZXhwcihbbGl0ZXJhbCgxKSwgbGl0ZXJhbCgnQWxpY2UnKV0pLAogKiAgICAgICAgICAgcm93X2V4cHIoW2xpdGVyYWwoMiksIGxpdGVyYWwoJ0JvYicpXSkKICogICAgICAgKS0+YXMoJ3QnLCBbJ2lkJywgJ25hbWUnXSkKICogICApCiAqCiAqIEdlbmVyYXRlczogU0VMRUNUICogRlJPTSAoVkFMVUVTICgxLCAnQWxpY2UnKSwgKDIsICdCb2InKSkgQVMgdChpZCwgbmFtZSkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":804,"slug":"order-by","name":"order_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"direction","type":[{"name":"SortDirection","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\SortDirection::..."},{"name":"nulls","type":[{"name":"NullsPosition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\NullsPosition::..."}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPUkRFUiBCWSBpdGVtLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":816,"slug":"asc","name":"asc","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nulls","type":[{"name":"NullsPosition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\NullsPosition::..."}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPUkRFUiBCWSBpdGVtIHdpdGggQVNDIGRpcmVjdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":825,"slug":"desc","name":"desc","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"nulls","type":[{"name":"NullsPosition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\NullsPosition::..."}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPUkRFUiBCWSBpdGVtIHdpdGggREVTQyBkaXJlY3Rpb24uCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":839,"slug":"cte","name":"cte","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columnNames","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"materialization","type":[{"name":"CTEMaterialization","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\CTEMaterialization::..."},{"name":"recursive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"CTE","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENURSAoQ29tbW9uIFRhYmxlIEV4cHJlc3Npb24pLgogKgogKiBAcGFyYW0gc3RyaW5nICRuYW1lIENURSBuYW1lCiAqIEBwYXJhbSBTZWxlY3RGaW5hbFN0ZXAgJHF1ZXJ5IENURSBxdWVyeQogKiBAcGFyYW0gYXJyYXk8c3RyaW5nPiAkY29sdW1uTmFtZXMgQ29sdW1uIGFsaWFzZXMgKG9wdGlvbmFsKQogKiBAcGFyYW0gQ1RFTWF0ZXJpYWxpemF0aW9uICRtYXRlcmlhbGl6YXRpb24gTWF0ZXJpYWxpemF0aW9uIGhpbnQKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":861,"slug":"window-def","name":"window_def","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"partitionBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"orderBy","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"frame","type":[{"name":"WindowFrame","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"WindowDefinition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHdpbmRvdyBkZWZpbml0aW9uIGZvciBXSU5ET1cgY2xhdXNlLgogKgogKiBAcGFyYW0gc3RyaW5nICRuYW1lIFdpbmRvdyBuYW1lCiAqIEBwYXJhbSBsaXN0PEV4cHJlc3Npb258c3RyaW5nPiAkcGFydGl0aW9uQnkgUEFSVElUSU9OIEJZIGV4cHJlc3Npb25zCiAqIEBwYXJhbSBsaXN0PE9yZGVyQnk+ICRvcmRlckJ5IE9SREVSIEJZIGl0ZW1zCiAqIEBwYXJhbSBudWxsfFdpbmRvd0ZyYW1lICRmcmFtZSBXaW5kb3cgZnJhbWUgc3BlY2lmaWNhdGlvbgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":881,"slug":"window-frame","name":"window_frame","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"mode","type":[{"name":"FrameMode","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"start","type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"end","type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"exclusion","type":[{"name":"FrameExclusion","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\FrameExclusion::..."}],"return_type":[{"name":"WindowFrame","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHdpbmRvdyBmcmFtZSBzcGVjaWZpY2F0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":894,"slug":"frame-current-row","name":"frame_current_row","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBDVVJSRU5UIFJPVy4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":903,"slug":"frame-unbounded-preceding","name":"frame_unbounded_preceding","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBVTkJPVU5ERUQgUFJFQ0VESU5HLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":912,"slug":"frame-unbounded-following","name":"frame_unbounded_following","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBVTkJPVU5ERUQgRk9MTE9XSU5HLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":921,"slug":"frame-preceding","name":"frame_preceding","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"offset","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBOIFBSRUNFRElORy4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":930,"slug":"frame-following","name":"frame_following","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"offset","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FrameBound","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZyYW1lIGJvdW5kIGZvciBOIEZPTExPV0lORy4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":943,"slug":"lock-for","name":"lock_for","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"strength","type":[{"name":"LockStrength","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"waitPolicy","type":[{"name":"LockWaitPolicy","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Clause\\LockWaitPolicy::..."}],"return_type":[{"name":"LockingClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxvY2tpbmcgY2xhdXNlIChGT1IgVVBEQVRFLCBGT1IgU0hBUkUsIGV0Yy4pLgogKgogKiBAcGFyYW0gTG9ja1N0cmVuZ3RoICRzdHJlbmd0aCBMb2NrIHN0cmVuZ3RoCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHRhYmxlcyBUYWJsZXMgdG8gbG9jayAoZW1wdHkgZm9yIGFsbCkKICogQHBhcmFtIExvY2tXYWl0UG9saWN5ICR3YWl0UG9saWN5IFdhaXQgcG9saWN5CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":957,"slug":"for-update","name":"for_update","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"LockingClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEZPUiBVUERBVEUgbG9ja2luZyBjbGF1c2UuCiAqCiAqIEBwYXJhbSBsaXN0PHN0cmluZz4gJHRhYmxlcyBUYWJsZXMgdG8gbG9jayAoZW1wdHkgZm9yIGFsbCkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":968,"slug":"for-share","name":"for_share","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"tables","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"LockingClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEZPUiBTSEFSRSBsb2NraW5nIGNsYXVzZS4KICoKICogQHBhcmFtIGxpc3Q8c3RyaW5nPiAkdGFibGVzIFRhYmxlcyB0byBsb2NrIChlbXB0eSBmb3IgYWxsKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":977,"slug":"on-conflict-nothing","name":"on_conflict_nothing","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"target","type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"OnConflictClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPTiBDT05GTElDVCBETyBOT1RISU5HIGNsYXVzZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":989,"slug":"on-conflict-update","name":"on_conflict_update","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"target","type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"updates","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OnConflictClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPTiBDT05GTElDVCBETyBVUERBVEUgY2xhdXNlLgogKgogKiBAcGFyYW0gQ29uZmxpY3RUYXJnZXQgJHRhcmdldCBDb25mbGljdCB0YXJnZXQgKGNvbHVtbnMgb3IgY29uc3RyYWludCkKICogQHBhcmFtIGFycmF5PHN0cmluZywgRXhwcmVzc2lvbnxzdHJpbmc+ICR1cGRhdGVzIENvbHVtbiB1cGRhdGVzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1003,"slug":"conflict-columns","name":"conflict_columns","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbmZsaWN0IHRhcmdldCBmb3IgT04gQ09ORkxJQ1QgKGNvbHVtbnMpLgogKgogKiBAcGFyYW0gbGlzdDxzdHJpbmc+ICRjb2x1bW5zIENvbHVtbnMgdGhhdCBkZWZpbmUgdW5pcXVlbmVzcwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1012,"slug":"conflict-constraint","name":"conflict_constraint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConflictTarget","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbmZsaWN0IHRhcmdldCBmb3IgT04gQ09ORkxJQ1QgT04gQ09OU1RSQUlOVC4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1023,"slug":"returning","name":"returning","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expressions","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ReturningClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVFVSTklORyBjbGF1c2UuCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAuLi4kZXhwcmVzc2lvbnMgRXhwcmVzc2lvbnMgdG8gcmV0dXJuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1034,"slug":"returning-all","name":"returning_all","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ReturningClause","namespace":"Flow\\PostgreSql\\QueryBuilder\\Clause","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJFVFVSTklORyAqIGNsYXVzZS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1046,"slug":"begin","name":"begin","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"BeginOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJFR0lOIHRyYW5zYWN0aW9uIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IGJlZ2luKCktPmlzb2xhdGlvbkxldmVsKElzb2xhdGlvbkxldmVsOjpTRVJJQUxJWkFCTEUpLT5yZWFkT25seSgpCiAqIFByb2R1Y2VzOiBCRUdJTiBJU09MQVRJT04gTEVWRUwgU0VSSUFMSVpBQkxFIFJFQUQgT05MWQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1058,"slug":"commit","name":"commit","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"CommitOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTU1JVCB0cmFuc2FjdGlvbiBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBjb21taXQoKS0+YW5kQ2hhaW4oKQogKiBQcm9kdWNlczogQ09NTUlUIEFORCBDSEFJTgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1070,"slug":"rollback","name":"rollback","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"RollbackOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJPTExCQUNLIHRyYW5zYWN0aW9uIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJvbGxiYWNrKCktPnRvU2F2ZXBvaW50KCdteV9zYXZlcG9pbnQnKQogKiBQcm9kdWNlczogUk9MTEJBQ0sgVE8gU0FWRVBPSU5UIG15X3NhdmVwb2ludAogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1082,"slug":"savepoint","name":"savepoint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SavepointFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNBVkVQT0lOVC4KICoKICogRXhhbXBsZTogc2F2ZXBvaW50KCdteV9zYXZlcG9pbnQnKQogKiBQcm9kdWNlczogU0FWRVBPSU5UIG15X3NhdmVwb2ludAogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1094,"slug":"release-savepoint","name":"release_savepoint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SavepointFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJlbGVhc2UgYSBTQVZFUE9JTlQuCiAqCiAqIEV4YW1wbGU6IHJlbGVhc2Vfc2F2ZXBvaW50KCdteV9zYXZlcG9pbnQnKQogKiBQcm9kdWNlczogUkVMRUFTRSBteV9zYXZlcG9pbnQKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1106,"slug":"set-transaction","name":"set_transaction","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SetTransactionOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBUUkFOU0FDVElPTiBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBzZXRfdHJhbnNhY3Rpb24oKS0+aXNvbGF0aW9uTGV2ZWwoSXNvbGF0aW9uTGV2ZWw6OlNFUklBTElaQUJMRSktPnJlYWRPbmx5KCkKICogUHJvZHVjZXM6IFNFVCBUUkFOU0FDVElPTiBJU09MQVRJT04gTEVWRUwgU0VSSUFMSVpBQkxFLCBSRUFEIE9OTFkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1118,"slug":"set-session-transaction","name":"set_session_transaction","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"SetTransactionOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBTRVNTSU9OIENIQVJBQ1RFUklTVElDUyBBUyBUUkFOU0FDVElPTiBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBzZXRfc2Vzc2lvbl90cmFuc2FjdGlvbigpLT5pc29sYXRpb25MZXZlbChJc29sYXRpb25MZXZlbDo6U0VSSUFMSVpBQkxFKQogKiBQcm9kdWNlczogU0VUIFNFU1NJT04gQ0hBUkFDVEVSSVNUSUNTIEFTIFRSQU5TQUNUSU9OIElTT0xBVElPTiBMRVZFTCBTRVJJQUxJWkFCTEUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1130,"slug":"transaction-snapshot","name":"transaction_snapshot","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"snapshotId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SetTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNFVCBUUkFOU0FDVElPTiBTTkFQU0hPVCBidWlsZGVyLgogKgogKiBFeGFtcGxlOiB0cmFuc2FjdGlvbl9zbmFwc2hvdCgnMDAwMDAwMDMtMDAwMDAwMUEtMScpCiAqIFByb2R1Y2VzOiBTRVQgVFJBTlNBQ1RJT04gU05BUFNIT1QgJzAwMDAwMDAzLTAwMDAwMDFBLTEnCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1142,"slug":"prepare-transaction","name":"prepare_transaction","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"transactionId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PreparedTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBSRVBBUkUgVFJBTlNBQ1RJT04gYnVpbGRlci4KICoKICogRXhhbXBsZTogcHJlcGFyZV90cmFuc2FjdGlvbignbXlfdHJhbnNhY3Rpb24nKQogKiBQcm9kdWNlczogUFJFUEFSRSBUUkFOU0FDVElPTiAnbXlfdHJhbnNhY3Rpb24nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1154,"slug":"commit-prepared","name":"commit_prepared","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"transactionId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PreparedTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENPTU1JVCBQUkVQQVJFRCBidWlsZGVyLgogKgogKiBFeGFtcGxlOiBjb21taXRfcHJlcGFyZWQoJ215X3RyYW5zYWN0aW9uJykKICogUHJvZHVjZXM6IENPTU1JVCBQUkVQQVJFRCAnbXlfdHJhbnNhY3Rpb24nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1166,"slug":"rollback-prepared","name":"rollback_prepared","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"transactionId","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PreparedTransactionFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Transaction","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJPTExCQUNLIFBSRVBBUkVEIGJ1aWxkZXIuCiAqCiAqIEV4YW1wbGU6IHJvbGxiYWNrX3ByZXBhcmVkKCdteV90cmFuc2FjdGlvbicpCiAqIFByb2R1Y2VzOiBST0xMQkFDSyBQUkVQQVJFRCAnbXlfdHJhbnNhY3Rpb24nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1189,"slug":"declare-cursor","name":"declare_cursor","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"cursorName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false},{"name":"Sql","namespace":"Flow\\PostgreSql\\QueryBuilder","is_nullable":false,"is_variadic":false},{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"DeclareCursorOptionsStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Cursor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERlY2xhcmUgYSBzZXJ2ZXItc2lkZSBjdXJzb3IgZm9yIGEgcXVlcnkuCiAqCiAqIEN1cnNvcnMgbXVzdCBiZSBkZWNsYXJlZCB3aXRoaW4gYSB0cmFuc2FjdGlvbiBhbmQgcHJvdmlkZSBtZW1vcnktZWZmaWNpZW50CiAqIGl0ZXJhdGlvbiBvdmVyIGxhcmdlIHJlc3VsdCBzZXRzIHZpYSBGRVRDSCBjb21tYW5kcy4KICoKICogRXhhbXBsZSB3aXRoIHF1ZXJ5IGJ1aWxkZXI6CiAqICAgZGVjbGFyZV9jdXJzb3IoJ215X2N1cnNvcicsIHNlbGVjdChzdGFyKCkpLT5mcm9tKHRhYmxlKCd1c2VycycpKSktPm5vU2Nyb2xsKCkKICogICBQcm9kdWNlczogREVDTEFSRSBteV9jdXJzb3IgTk8gU0NST0xMIENVUlNPUiBGT1IgU0VMRUNUICogRlJPTSB1c2VycwogKgogKiBFeGFtcGxlIHdpdGggcmF3IFNRTDoKICogICBkZWNsYXJlX2N1cnNvcignbXlfY3Vyc29yJywgJ1NFTEVDVCAqIEZST00gdXNlcnMgV0hFUkUgYWN0aXZlID0gdHJ1ZScpLT53aXRoSG9sZCgpCiAqICAgUHJvZHVjZXM6IERFQ0xBUkUgbXlfY3Vyc29yIE5PIFNDUk9MTCBDVVJTT1IgV0lUSCBIT0xEIEZPUiBTRUxFQ1QgKiBGUk9NIHVzZXJzIFdIRVJFIGFjdGl2ZSA9IHRydWUKICoKICogQHBhcmFtIHN0cmluZyAkY3Vyc29yTmFtZSBVbmlxdWUgY3Vyc29yIG5hbWUKICogQHBhcmFtIFBhcnNlZFF1ZXJ5fFNlbGVjdEZpbmFsU3RlcHxTcWx8c3RyaW5nICRxdWVyeSBRdWVyeSB0byBpdGVyYXRlIG92ZXIKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1214,"slug":"fetch","name":"fetch","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"cursorName","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"FetchCursorBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Cursor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEZldGNoIHJvd3MgZnJvbSBhIGN1cnNvci4KICoKICogRXhhbXBsZTogZmV0Y2goJ215X2N1cnNvcicpLT5mb3J3YXJkKDEwMCkKICogUHJvZHVjZXM6IEZFVENIIEZPUldBUkQgMTAwIG15X2N1cnNvcgogKgogKiBFeGFtcGxlOiBmZXRjaCgnbXlfY3Vyc29yJyktPmFsbCgpCiAqIFByb2R1Y2VzOiBGRVRDSCBBTEwgbXlfY3Vyc29yCiAqCiAqIEBwYXJhbSBzdHJpbmcgJGN1cnNvck5hbWUgQ3Vyc29yIHRvIGZldGNoIGZyb20KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/query.php","start_line_in_file":1231,"slug":"close-cursor","name":"close_cursor","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"cursorName","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CloseCursorFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Cursor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENsb3NlIGEgY3Vyc29yLgogKgogKiBFeGFtcGxlOiBjbG9zZV9jdXJzb3IoJ215X2N1cnNvcicpCiAqIFByb2R1Y2VzOiBDTE9TRSBteV9jdXJzb3IKICoKICogRXhhbXBsZTogY2xvc2VfY3Vyc29yKCkgLSBjbG9zZXMgYWxsIGN1cnNvcnMKICogUHJvZHVjZXM6IENMT1NFIEFMTAogKgogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGN1cnNvck5hbWUgQ3Vyc29yIHRvIGNsb3NlLCBvciBudWxsIHRvIGNsb3NlIGFsbAogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":42,"slug":"eq","name":"eq","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBlcXVhbGl0eSBjb21wYXJpc29uIChjb2x1bW4gPSB2YWx1ZSkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":55,"slug":"ne","name":"ne","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5vdC1lcXVhbCBjb21wYXJpc29uIChjb2x1bW4gIT0gdmFsdWUpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":68,"slug":"lt","name":"lt","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxlc3MtdGhhbiBjb21wYXJpc29uIChjb2x1bW4gPCB2YWx1ZSkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":81,"slug":"le","name":"le","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxlc3MtdGhhbi1vci1lcXVhbCBjb21wYXJpc29uIChjb2x1bW4gPD0gdmFsdWUpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":94,"slug":"gt","name":"gt","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGdyZWF0ZXItdGhhbiBjb21wYXJpc29uIChjb2x1bW4gPiB2YWx1ZSkuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":107,"slug":"ge","name":"ge","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Comparison","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGdyZWF0ZXItdGhhbi1vci1lcXVhbCBjb21wYXJpc29uIChjb2x1bW4gPj0gdmFsdWUpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":120,"slug":"between","name":"between","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"low","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"high","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"not","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Between","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJFVFdFRU4gY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":139,"slug":"in","name":"in_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"values","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"In","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJTiBjb25kaXRpb24uCiAqCiAqIEBwYXJhbSBFeHByZXNzaW9ufHN0cmluZyAkZXhwciBFeHByZXNzaW9uIHRvIGNoZWNrCiAqIEBwYXJhbSBsaXN0PEV4cHJlc3Npb24+ICR2YWx1ZXMgTGlzdCBvZiB2YWx1ZXMgKG11c3QgYmUgbm9uLWVtcHR5KQogKgogKiBAdGhyb3dzIFxJbnZhbGlkQXJndW1lbnRFeGNlcHRpb24gd2hlbiB2YWx1ZXMgYXJyYXkgaXMgZW1wdHkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":156,"slug":"is-null","name":"is_null","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"not","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"IsNull","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJUyBOVUxMIGNvbmRpdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":165,"slug":"like","name":"like","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"caseInsensitive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"negated","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Like","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExJS0UgY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":183,"slug":"similar-to","name":"similar_to","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SimilarTo","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNJTUlMQVIgVE8gY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":195,"slug":"distinct-from","name":"distinct_from","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"not","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"IsDistinctFrom","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJUyBESVNUSU5DVCBGUk9NIGNvbmRpdGlvbi4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":208,"slug":"exists","name":"exists","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"subquery","type":[{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Exists","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFWElTVFMgY29uZGl0aW9uLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":223,"slug":"any","name":"any_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"operator","type":[{"name":"ComparisonOperator","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"arrayOrSubquery","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBTlkgY29uZGl0aW9uIHdpdGggYSBzdWJxdWVyeSBvciBhcnJheSBleHByZXNzaW9uLgogKgogKiBFeGFtcGxlOiBhbnlfKGNvbCgnaWQnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpFUSwgc2VsZWN0KGNvbCgndXNlcl9pZCcpKS0+ZnJvbSh0YWJsZSgnb3JkZXJzJykpKQogKiBFeGFtcGxlOiBhbnlfKGNvbCgnYXR0bnVtJywgJ2EnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpFUSwgY29sKCdjb25rZXknLCAnY29uJykpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":243,"slug":"all","name":"all_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"operator","type":[{"name":"ComparisonOperator","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"arrayOrSubquery","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"SelectFinalStep","namespace":"Flow\\PostgreSql\\QueryBuilder\\Select","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBTEwgY29uZGl0aW9uIHdpdGggYSBzdWJxdWVyeSBvciBhcnJheSBleHByZXNzaW9uLgogKgogKiBFeGFtcGxlOiBhbGxfKGNvbCgnaWQnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpFUSwgc2VsZWN0KGNvbCgndXNlcl9pZCcpKS0+ZnJvbSh0YWJsZSgnb3JkZXJzJykpKQogKiBFeGFtcGxlOiBhbGxfKGNvbCgndmFsdWUnKSwgQ29tcGFyaXNvbk9wZXJhdG9yOjpHVCwgY29sKCd0aHJlc2hvbGRzJykpCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":262,"slug":"is-true","name":"is_true","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BooleanCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYW4gZXhwcmVzc2lvbiBhcyBhIGJvb2xlYW4gY29uZGl0aW9uIGZvciB1c2UgaW4gV0hFUkUvSEFWSU5HL0pPSU4gT04uCiAqCiAqIEV4YW1wbGU6IGlzX3RydWUoY29sKCdpc19hY3RpdmUnKSkg4oCUIHVzZXMgYSBib29sZWFuIGNvbHVtbiBpbiBXSEVSRSBjbGF1c2UuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":274,"slug":"not-like","name":"not_like","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"caseInsensitive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"Like","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE5PVCBMSUtFIGNvbmRpdGlvbi4KICoKICogRXhhbXBsZTogbm90X2xpa2UoY29sKCduYW1lJyksIGxpdGVyYWwoJ3BnXyUnKSkKICogUHJvZHVjZXM6IG5hbWUgTk9UIExJS0UgJ3BnXyUnCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":302,"slug":"conditions","name":"conditions","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"ConditionBuilder","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGNvbmRpdGlvbiBidWlsZGVyIGZvciBmbHVlbnQgY29uZGl0aW9uIGNvbXBvc2l0aW9uLgogKgogKiBUaGlzIGJ1aWxkZXIgYWxsb3dzIGluY3JlbWVudGFsIGNvbmRpdGlvbiBidWlsZGluZyB3aXRoIGEgZmx1ZW50IEFQSToKICoKICogYGBgcGhwCiAqICRidWlsZGVyID0gY29uZGl0aW9ucygpOwogKgogKiBpZiAoJGhhc0ZpbHRlcikgewogKiAgICAgJGJ1aWxkZXIgPSAkYnVpbGRlci0+YW5kKGVxKGNvbCgnc3RhdHVzJyksIGxpdGVyYWwoJ2FjdGl2ZScpKSk7CiAqIH0KICoKICogaWYgKCEkYnVpbGRlci0+aXNFbXB0eSgpKSB7CiAqICAgICAkcXVlcnkgPSBzZWxlY3QoKS0+ZnJvbSh0YWJsZSgndXNlcnMnKSktPndoZXJlKCRidWlsZGVyKTsKICogfQogKiBgYGAKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":313,"slug":"and","name":"and_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"conditions","type":[{"name":"Condition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"AndCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgY29uZGl0aW9ucyB3aXRoIEFORC4KICoKICogQHBhcmFtIENvbmRpdGlvbiAuLi4kY29uZGl0aW9ucyBDb25kaXRpb25zIHRvIGNvbWJpbmUKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":324,"slug":"or","name":"or_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"conditions","type":[{"name":"Condition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"OrCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgY29uZGl0aW9ucyB3aXRoIE9SLgogKgogKiBAcGFyYW0gQ29uZGl0aW9uIC4uLiRjb25kaXRpb25zIENvbmRpdGlvbnMgdG8gY29tYmluZQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":336,"slug":"not","name":"not_","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expression","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"NotCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5lZ2F0ZSBhIGNvbmRpdGlvbiBvciBleHByZXNzaW9uIHdpdGggTk9ULgogKgogKiBBY2NlcHRzIGJvdGggQ29uZGl0aW9uIGFuZCBFeHByZXNzaW9uIOKAlCBOT1QgYWx3YXlzIHByb2R1Y2VzIGEgYm9vbGVhbiByZXN1bHQuCiAqIENhbiBiZSB1c2VkIGluIFdIRVJFIGNsYXVzZXMgYW5kIFNFTEVDVCBsaXN0cyAodmlhIC0+YXMoJ2FsaWFzJykpLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":348,"slug":"json-contains","name":"json_contains","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGNvbnRhaW5zIGNvbmRpdGlvbiAoQD4pLgogKgogKiBFeGFtcGxlOiBqc29uX2NvbnRhaW5zKGNvbCgnbWV0YWRhdGEnKSwgbGl0ZXJhbF9qc29uKCd7ImNhdGVnb3J5IjogImVsZWN0cm9uaWNzIn0nKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhIEA+ICd7ImNhdGVnb3J5IjogImVsZWN0cm9uaWNzIn0nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":364,"slug":"json-contained-by","name":"json_contained_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGlzIGNvbnRhaW5lZCBieSBjb25kaXRpb24gKDxAKS4KICoKICogRXhhbXBsZToganNvbl9jb250YWluZWRfYnkoY29sKCdtZXRhZGF0YScpLCBsaXRlcmFsX2pzb24oJ3siY2F0ZWdvcnkiOiAiZWxlY3Ryb25pY3MiLCAicHJpY2UiOiAxMDB9JykpCiAqIFByb2R1Y2VzOiBtZXRhZGF0YSA8QCAneyJjYXRlZ29yeSI6ICJlbGVjdHJvbmljcyIsICJwcmljZSI6IDEwMH0nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":381,"slug":"json-get","name":"json_get","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gZmllbGQgYWNjZXNzIGV4cHJlc3Npb24gKC0+KS4KICogUmV0dXJucyBKU09OLgogKgogKiBFeGFtcGxlOiBqc29uX2dldChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCdjYXRlZ29yeScpKQogKiBQcm9kdWNlczogbWV0YWRhdGEgLT4gJ2NhdGVnb3J5JwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":398,"slug":"json-get-text","name":"json_get_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gZmllbGQgYWNjZXNzIGV4cHJlc3Npb24gKC0+PikuCiAqIFJldHVybnMgdGV4dC4KICoKICogRXhhbXBsZToganNvbl9nZXRfdGV4dChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCduYW1lJykpCiAqIFByb2R1Y2VzOiBtZXRhZGF0YSAtPj4gJ25hbWUnCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":415,"slug":"json-path","name":"json_path","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gcGF0aCBhY2Nlc3MgZXhwcmVzc2lvbiAoIz4pLgogKiBSZXR1cm5zIEpTT04uCiAqCiAqIEV4YW1wbGU6IGpzb25fcGF0aChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCd7Y2F0ZWdvcnksbmFtZX0nKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhICM+ICd7Y2F0ZWdvcnksbmFtZX0nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":432,"slug":"json-path-text","name":"json_path_text","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"path","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"BinaryExpression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gcGF0aCBhY2Nlc3MgZXhwcmVzc2lvbiAoIz4+KS4KICogUmV0dXJucyB0ZXh0LgogKgogKiBFeGFtcGxlOiBqc29uX3BhdGhfdGV4dChjb2woJ21ldGFkYXRhJyksIGxpdGVyYWxfc3RyaW5nKCd7Y2F0ZWdvcnksbmFtZX0nKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhICM+PiAne2NhdGVnb3J5LG5hbWV9JwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":448,"slug":"json-exists","name":"json_exists","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGtleSBleGlzdHMgY29uZGl0aW9uICg\/KS4KICoKICogRXhhbXBsZToganNvbl9leGlzdHMoY29sKCdtZXRhZGF0YScpLCBsaXRlcmFsX3N0cmluZygnY2F0ZWdvcnknKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhID8gJ2NhdGVnb3J5JwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":464,"slug":"json-exists-any","name":"json_exists_any","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGFueSBrZXkgZXhpc3RzIGNvbmRpdGlvbiAoP3wpLgogKgogKiBFeGFtcGxlOiBqc29uX2V4aXN0c19hbnkoY29sKCdtZXRhZGF0YScpLCBhcnJheV9leHByKFtsaXRlcmFsKCdjYXRlZ29yeScpLCBsaXRlcmFsKCduYW1lJyldKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhID98IGFycmF5WydjYXRlZ29yeScsICduYW1lJ10KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":480,"slug":"json-exists-all","name":"json_exists_all","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"keys","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT05CIGFsbCBrZXlzIGV4aXN0IGNvbmRpdGlvbiAoPyYpLgogKgogKiBFeGFtcGxlOiBqc29uX2V4aXN0c19hbGwoY29sKCdtZXRhZGF0YScpLCBhcnJheV9leHByKFtsaXRlcmFsKCdjYXRlZ29yeScpLCBsaXRlcmFsKCduYW1lJyldKSkKICogUHJvZHVjZXM6IG1ldGFkYXRhID8mIGFycmF5WydjYXRlZ29yeScsICduYW1lJ10KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":496,"slug":"array-contains","name":"array_contains","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBjb250YWlucyBjb25kaXRpb24gKEA+KS4KICoKICogRXhhbXBsZTogYXJyYXlfY29udGFpbnMoY29sKCd0YWdzJyksIGFycmF5X2V4cHIoW2xpdGVyYWwoJ3NhbGUnKV0pKQogKiBQcm9kdWNlczogdGFncyBAPiBBUlJBWVsnc2FsZSddCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":512,"slug":"array-contained-by","name":"array_contained_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBpcyBjb250YWluZWQgYnkgY29uZGl0aW9uICg8QCkuCiAqCiAqIEV4YW1wbGU6IGFycmF5X2NvbnRhaW5lZF9ieShjb2woJ3RhZ3MnKSwgYXJyYXlfZXhwcihbbGl0ZXJhbCgnc2FsZScpLCBsaXRlcmFsKCdmZWF0dXJlZCcpLCBsaXRlcmFsKCduZXcnKV0pKQogKiBQcm9kdWNlczogdGFncyA8QCBBUlJBWVsnc2FsZScsICdmZWF0dXJlZCcsICduZXcnXQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":528,"slug":"array-overlap","name":"array_overlap","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"left","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"right","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhcnJheSBvdmVybGFwIGNvbmRpdGlvbiAoJiYpLgogKgogKiBFeGFtcGxlOiBhcnJheV9vdmVybGFwKGNvbCgndGFncycpLCBhcnJheV9leHByKFtsaXRlcmFsKCdzYWxlJyksIGxpdGVyYWwoJ2ZlYXR1cmVkJyldKSkKICogUHJvZHVjZXM6IHRhZ3MgJiYgQVJSQVlbJ3NhbGUnLCAnZmVhdHVyZWQnXQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":546,"slug":"regex-match","name":"regex_match","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG1hdGNoIGNvbmRpdGlvbiAofikuCiAqIENhc2Utc2Vuc2l0aXZlLgogKgogKiBFeGFtcGxlOiByZWdleF9tYXRjaChjb2woJ2VtYWlsJyksIGxpdGVyYWxfc3RyaW5nKCcuKkBnbWFpbFxcLmNvbScpKQogKgogKiBQcm9kdWNlczogZW1haWwgfiAnLipAZ21haWxcLmNvbScKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":564,"slug":"regex-imatch","name":"regex_imatch","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG1hdGNoIGNvbmRpdGlvbiAofiopLgogKiBDYXNlLWluc2Vuc2l0aXZlLgogKgogKiBFeGFtcGxlOiByZWdleF9pbWF0Y2goY29sKCdlbWFpbCcpLCBsaXRlcmFsX3N0cmluZygnLipAZ21haWxcXC5jb20nKSkKICoKICogUHJvZHVjZXM6IGVtYWlsIH4qICcuKkBnbWFpbFwuY29tJwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":582,"slug":"not-regex-match","name":"not_regex_match","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG5vdCBtYXRjaCBjb25kaXRpb24gKCF+KS4KICogQ2FzZS1zZW5zaXRpdmUuCiAqCiAqIEV4YW1wbGU6IG5vdF9yZWdleF9tYXRjaChjb2woJ2VtYWlsJyksIGxpdGVyYWxfc3RyaW5nKCcuKkBzcGFtXFwuY29tJykpCiAqCiAqIFByb2R1Y2VzOiBlbWFpbCAhfiAnLipAc3BhbVwuY29tJwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":600,"slug":"not-regex-imatch","name":"not_regex_imatch","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"expr","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"pattern","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBPU0lYIHJlZ2V4IG5vdCBtYXRjaCBjb25kaXRpb24gKCF+KikuCiAqIENhc2UtaW5zZW5zaXRpdmUuCiAqCiAqIEV4YW1wbGU6IG5vdF9yZWdleF9pbWF0Y2goY29sKCdlbWFpbCcpLCBsaXRlcmFsX3N0cmluZygnLipAc3BhbVxcLmNvbScpKQogKgogKiBQcm9kdWNlczogZW1haWwgIX4qICcuKkBzcGFtXC5jb20nCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/condition.php","start_line_in_file":616,"slug":"text-search-match","name":"text_search_match","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"document","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"query","type":[{"name":"Expression","namespace":"Flow\\PostgreSql\\QueryBuilder\\Expression","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OperatorCondition","namespace":"Flow\\PostgreSql\\QueryBuilder\\Condition","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGZ1bGwtdGV4dCBzZWFyY2ggbWF0Y2ggY29uZGl0aW9uIChAQCkuCiAqCiAqIEV4YW1wbGU6IHRleHRfc2VhcmNoX21hdGNoKGNvbCgnZG9jdW1lbnQnKSwgZnVuYygndG9fdHNxdWVyeScsIFtsaXRlcmFsKCdlbmdsaXNoJyksIGxpdGVyYWwoJ2hlbGxvICYgd29ybGQnKV0pKQogKiBQcm9kdWNlczogZG9jdW1lbnQgQEAgdG9fdHNxdWVyeSgnZW5nbGlzaCcsICdoZWxsbyAmIHdvcmxkJykKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":33,"slug":"sql-parser","name":"sql_parser","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"Parser","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":39,"slug":"sql-parse","name":"sql_parse","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":49,"slug":"sql-fingerprint","name":"sql_fingerprint","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFJldHVybnMgYSBmaW5nZXJwcmludCBvZiB0aGUgZ2l2ZW4gU1FMIHF1ZXJ5LgogKiBMaXRlcmFsIHZhbHVlcyBhcmUgbm9ybWFsaXplZCBzbyB0aGV5IHdvbid0IGFmZmVjdCB0aGUgZmluZ2VycHJpbnQuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":60,"slug":"sql-normalize","name":"sql_normalize","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5vcm1hbGl6ZSBTUUwgcXVlcnkgYnkgcmVwbGFjaW5nIGxpdGVyYWwgdmFsdWVzIGFuZCBuYW1lZCBwYXJhbWV0ZXJzIHdpdGggcG9zaXRpb25hbCBwYXJhbWV0ZXJzLgogKiBXSEVSRSBpZCA9IDppZCB3aWxsIGJlIGNoYW5nZWQgaW50byBXSEVSRSBpZCA9ICQxCiAqIFdIRVJFIGlkID0gMSB3aWxsIGJlIGNoYW5nZWQgaW50byBXSEVSRSBpZCA9ICQxLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":70,"slug":"sql-normalize-utility","name":"sql_normalize_utility","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5vcm1hbGl6ZSB1dGlsaXR5IFNRTCBzdGF0ZW1lbnRzIChEREwgbGlrZSBDUkVBVEUsIEFMVEVSLCBEUk9QKS4KICogVGhpcyBoYW5kbGVzIERETCBzdGF0ZW1lbnRzIGRpZmZlcmVudGx5IGZyb20gcGdfbm9ybWFsaXplKCkgd2hpY2ggaXMgb3B0aW1pemVkIGZvciBETUwuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":81,"slug":"sql-split","name":"sql_split","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFNwbGl0IHN0cmluZyB3aXRoIG11bHRpcGxlIFNRTCBzdGF0ZW1lbnRzIGludG8gYXJyYXkgb2YgaW5kaXZpZHVhbCBzdGF0ZW1lbnRzLgogKgogKiBAcmV0dXJuIGFycmF5PHN0cmluZz4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":90,"slug":"sql-deparse-options","name":"sql_deparse_options","namespace":"Flow\\PostgreSql\\DSL","parameters":[],"return_type":[{"name":"DeparseOptions","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBEZXBhcnNlT3B0aW9ucyBmb3IgY29uZmlndXJpbmcgU1FMIGZvcm1hdHRpbmcuCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":104,"slug":"sql-deparse","name":"sql_deparse","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"DeparseOptions","namespace":"Flow\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbnZlcnQgYSBQYXJzZWRRdWVyeSBBU1QgYmFjayB0byBTUUwgc3RyaW5nLgogKgogKiBXaGVuIGNhbGxlZCB3aXRob3V0IG9wdGlvbnMsIHJldHVybnMgdGhlIFNRTCBhcyBhIHNpbXBsZSBzdHJpbmcuCiAqIFdoZW4gY2FsbGVkIHdpdGggRGVwYXJzZU9wdGlvbnMsIGFwcGxpZXMgZm9ybWF0dGluZyAocHJldHR5LXByaW50aW5nLCBpbmRlbnRhdGlvbiwgZXRjLikuCiAqCiAqIEB0aHJvd3MgXFJ1bnRpbWVFeGNlcHRpb24gaWYgZGVwYXJzaW5nIGZhaWxzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":120,"slug":"sql-format","name":"sql_format","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"DeparseOptions","namespace":"Flow\\PostgreSql","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcnNlIGFuZCBmb3JtYXQgU1FMIHF1ZXJ5IHdpdGggcHJldHR5IHByaW50aW5nLgogKgogKiBUaGlzIGlzIGEgY29udmVuaWVuY2UgZnVuY3Rpb24gdGhhdCBwYXJzZXMgU1FMIGFuZCByZXR1cm5zIGl0IGZvcm1hdHRlZC4KICoKICogQHBhcmFtIHN0cmluZyAkc3FsIFRoZSBTUUwgcXVlcnkgdG8gZm9ybWF0CiAqIEBwYXJhbSBudWxsfERlcGFyc2VPcHRpb25zICRvcHRpb25zIEZvcm1hdHRpbmcgb3B0aW9ucyAoZGVmYXVsdHMgdG8gcHJldHR5LXByaW50IGVuYWJsZWQpCiAqCiAqIEB0aHJvd3MgXFJ1bnRpbWVFeGNlcHRpb24gaWYgcGFyc2luZyBvciBkZXBhcnNpbmcgZmFpbHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":132,"slug":"sql-summary","name":"sql_summary","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"},{"name":"truncateLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdlbmVyYXRlIGEgc3VtbWFyeSBvZiBwYXJzZWQgcXVlcmllcyBpbiBwcm90b2J1ZiBmb3JtYXQuCiAqIFVzZWZ1bCBmb3IgcXVlcnkgbW9uaXRvcmluZyBhbmQgbG9nZ2luZyB3aXRob3V0IGZ1bGwgQVNUIG92ZXJoZWFkLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":147,"slug":"sql-to-paginated-query","name":"sql_to_paginated_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"offset","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"0"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGEgcGFnaW5hdGVkIHF1ZXJ5IHdpdGggTElNSVQgYW5kIE9GRlNFVC4KICoKICogQHBhcmFtIHN0cmluZyAkc3FsIFRoZSBTUUwgcXVlcnkgdG8gcGFnaW5hdGUKICogQHBhcmFtIGludCAkbGltaXQgTWF4aW11bSBudW1iZXIgb2Ygcm93cyB0byByZXR1cm4KICogQHBhcmFtIGludCAkb2Zmc2V0IE51bWJlciBvZiByb3dzIHRvIHNraXAgKHJlcXVpcmVzIE9SREVSIEJZIGluIHF1ZXJ5KQogKgogKiBAcmV0dXJuIHN0cmluZyBUaGUgcGFnaW5hdGVkIFNRTCBxdWVyeQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":164,"slug":"sql-to-limited-query","name":"sql_to_limited_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSB0byBsaW1pdCByZXN1bHRzIHRvIGEgc3BlY2lmaWMgbnVtYmVyIG9mIHJvd3MuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJHNxbCBUaGUgU1FMIHF1ZXJ5IHRvIGxpbWl0CiAqIEBwYXJhbSBpbnQgJGxpbWl0IE1heGltdW0gbnVtYmVyIG9mIHJvd3MgdG8gcmV0dXJuCiAqCiAqIEByZXR1cm4gc3RyaW5nIFRoZSBsaW1pdGVkIFNRTCBxdWVyeQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":183,"slug":"sql-to-count-query","name":"sql_to_count_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGEgQ09VTlQgcXVlcnkgZm9yIHBhZ2luYXRpb24uCiAqCiAqIFdyYXBzIHRoZSBxdWVyeSBpbjogU0VMRUNUIENPVU5UKCopIEZST00gKC4uLikgQVMgX2NvdW50X3N1YnEKICogUmVtb3ZlcyBPUkRFUiBCWSBhbmQgTElNSVQvT0ZGU0VUIGZyb20gdGhlIGlubmVyIHF1ZXJ5LgogKgogKiBAcGFyYW0gc3RyaW5nICRzcWwgVGhlIFNRTCBxdWVyeSB0byB0cmFuc2Zvcm0KICoKICogQHJldHVybiBzdHJpbmcgVGhlIENPVU5UIHF1ZXJ5CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":205,"slug":"sql-to-keyset-query","name":"sql_to_keyset_query","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"columns","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"cursor","type":[{"name":"array","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGEga2V5c2V0IChjdXJzb3ItYmFzZWQpIHBhZ2luYXRlZCBxdWVyeS4KICoKICogTW9yZSBlZmZpY2llbnQgdGhhbiBPRkZTRVQgZm9yIGxhcmdlIGRhdGFzZXRzIC0gdXNlcyBpbmRleGVkIFdIRVJFIGNvbmRpdGlvbnMuCiAqIEF1dG9tYXRpY2FsbHkgZGV0ZWN0cyBleGlzdGluZyBxdWVyeSBwYXJhbWV0ZXJzIGFuZCBhcHBlbmRzIGtleXNldCBwbGFjZWhvbGRlcnMgYXQgdGhlIGVuZC4KICoKICogQHBhcmFtIHN0cmluZyAkc3FsIFRoZSBTUUwgcXVlcnkgdG8gcGFnaW5hdGUgKE9SREVSIEJZIG9wdGlvbmFsOyB3aGVuIHByZXNlbnQgaXQgbXVzdCBlcXVhbCB0aGUga2V5czsgbm8gTElNSVQvT0ZGU0VUKQogKiBAcGFyYW0gaW50ICRsaW1pdCBNYXhpbXVtIG51bWJlciBvZiByb3dzIHRvIHJldHVybgogKiBAcGFyYW0gbGlzdDxLZXlzZXRDb2x1bW4+ICRjb2x1bW5zIENvbHVtbnMgZm9yIGtleXNldCBwYWdpbmF0aW9uIChtdXN0IG1hdGNoIE9SREVSIEJZKQogKiBAcGFyYW0gbnVsbHxsaXN0PGJvb2x8ZmxvYXR8aW50fHN0cmluZz4gJGN1cnNvciBWYWx1ZXMgZnJvbSBsYXN0IHJvdyBvZiBwcmV2aW91cyBwYWdlIChudWxsIGZvciBmaXJzdCBwYWdlKQogKgogKiBAcmV0dXJuIHN0cmluZyBUaGUgcGFnaW5hdGVkIFNRTCBxdWVyeQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":220,"slug":"sql-keyset-column","name":"sql_keyset_column","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"column","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"order","type":[{"name":"SortOrder","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\AST\\Transformers\\SortOrder::..."}],"return_type":[{"name":"KeysetColumn","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEtleXNldENvbHVtbiBmb3Iga2V5c2V0IHBhZ2luYXRpb24uCiAqCiAqIEBwYXJhbSBzdHJpbmcgJGNvbHVtbiBDb2x1bW4gbmFtZSAoY2FuIGluY2x1ZGUgdGFibGUgYWxpYXMgbGlrZSAidS5pZCIpCiAqIEBwYXJhbSBTb3J0T3JkZXIgJG9yZGVyIFNvcnQgb3JkZXIgKEFTQyBvciBERVNDKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":229,"slug":"sql-query-columns","name":"sql_query_columns","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Columns","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgY29sdW1ucyBmcm9tIGEgcGFyc2VkIFNRTCBxdWVyeS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":238,"slug":"sql-query-tables","name":"sql_query_tables","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Tables","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgdGFibGVzIGZyb20gYSBwYXJzZWQgU1FMIHF1ZXJ5LgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":247,"slug":"sql-query-functions","name":"sql_query_functions","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Functions","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgZnVuY3Rpb25zIGZyb20gYSBwYXJzZWQgU1FMIHF1ZXJ5LgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":256,"slug":"sql-query-order-by","name":"sql_query_order_by","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"query","type":[{"name":"ParsedQuery","namespace":"Flow\\PostgreSql","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"OrderBy","namespace":"Flow\\PostgreSql\\Extractors","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEV4dHJhY3QgT1JERVIgQlkgY2xhdXNlcyBmcm9tIGEgcGFyc2VkIFNRTCBxdWVyeS4KICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":270,"slug":"sql-query-depth","name":"sql_query_depth","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEdldCB0aGUgbWF4aW11bSBuZXN0aW5nIGRlcHRoIG9mIGEgU1FMIHF1ZXJ5LgogKgogKiBFeGFtcGxlOgogKiAtICJTRUxFQ1QgKiBGUk9NIHQiID0+IDEKICogLSAiU0VMRUNUICogRlJPTSAoU0VMRUNUICogRlJPTSB0KSIgPT4gMgogKiAtICJTRUxFQ1QgKiBGUk9NIChTRUxFQ1QgKiBGUk9NIChTRUxFQ1QgKiBGUk9NIHQpKSIgPT4gMwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":287,"slug":"sql-to-explain","name":"sql_to_explain","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"sql","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"config","type":[{"name":"ExplainConfig","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFRyYW5zZm9ybSBhIFNRTCBxdWVyeSBpbnRvIGFuIEVYUExBSU4gcXVlcnkuCiAqCiAqIFJldHVybnMgdGhlIG1vZGlmaWVkIFNRTCB3aXRoIEVYUExBSU4gd3JhcHBlZCBhcm91bmQgaXQuCiAqIERlZmF1bHRzIHRvIEVYUExBSU4gQU5BTFlaRSB3aXRoIEpTT04gZm9ybWF0IGZvciBlYXN5IHBhcnNpbmcuCiAqCiAqIEBwYXJhbSBzdHJpbmcgJHNxbCBUaGUgU1FMIHF1ZXJ5IHRvIGV4cGxhaW4KICogQHBhcmFtIG51bGx8RXhwbGFpbkNvbmZpZyAkY29uZmlnIEVYUExBSU4gY29uZmlndXJhdGlvbiAoZGVmYXVsdHMgdG8gZm9yQW5hbHlzaXMoKSkKICoKICogQHJldHVybiBzdHJpbmcgVGhlIEVYUExBSU4gcXVlcnkKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":307,"slug":"sql-explain-config","name":"sql_explain_config","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"analyze","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"verbose","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"costs","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"buffers","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"timing","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"format","type":[{"name":"ExplainFormat","namespace":"Flow\\PostgreSql\\QueryBuilder\\Utility","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\QueryBuilder\\Utility\\ExplainFormat::..."}],"return_type":[{"name":"ExplainConfig","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFeHBsYWluQ29uZmlnIGZvciBjdXN0b21pemluZyBFWFBMQUlOIG9wdGlvbnMuCiAqCiAqIEBwYXJhbSBib29sICRhbmFseXplIFdoZXRoZXIgdG8gYWN0dWFsbHkgZXhlY3V0ZSB0aGUgcXVlcnkgKEFOQUxZWkUpCiAqIEBwYXJhbSBib29sICR2ZXJib3NlIEluY2x1ZGUgdmVyYm9zZSBvdXRwdXQKICogQHBhcmFtIGJvb2wgJGNvc3RzIEluY2x1ZGUgY29zdCBlc3RpbWF0ZXMgKGRlZmF1bHQgdHJ1ZSkKICogQHBhcmFtIGJvb2wgJGJ1ZmZlcnMgSW5jbHVkZSBidWZmZXIgdXNhZ2Ugc3RhdGlzdGljcyAocmVxdWlyZXMgYW5hbHl6ZSkKICogQHBhcmFtIGJvb2wgJHRpbWluZyBJbmNsdWRlIHRpbWluZyBpbmZvcm1hdGlvbiAocmVxdWlyZXMgYW5hbHl6ZSkKICogQHBhcmFtIEV4cGxhaW5Gb3JtYXQgJGZvcm1hdCBPdXRwdXQgZm9ybWF0IChKU09OIHJlY29tbWVuZGVkIGZvciBwYXJzaW5nKQogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":329,"slug":"sql-explain-modifier","name":"sql_explain_modifier","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"config","type":[{"name":"ExplainConfig","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ExplainModifier","namespace":"Flow\\PostgreSql\\AST\\Transformers","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFeHBsYWluTW9kaWZpZXIgZm9yIHRyYW5zZm9ybWluZyBxdWVyaWVzIGludG8gRVhQTEFJTiBxdWVyaWVzLgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":342,"slug":"sql-explain-parse","name":"sql_explain_parse","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"jsonOutput","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Plan","namespace":"Flow\\PostgreSql\\Explain\\Plan","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcnNlIEVYUExBSU4gSlNPTiBvdXRwdXQgaW50byBhIFBsYW4gb2JqZWN0LgogKgogKiBAcGFyYW0gc3RyaW5nICRqc29uT3V0cHV0IFRoZSBKU09OIG91dHB1dCBmcm9tIEVYUExBSU4gKEZPUk1BVCBKU09OKQogKgogKiBAcmV0dXJuIFBsYW4gVGhlIHBhcnNlZCBleGVjdXRpb24gcGxhbgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/parser.php","start_line_in_file":355,"slug":"sql-analyze","name":"sql_analyze","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"plan","type":[{"name":"Plan","namespace":"Flow\\PostgreSql\\Explain\\Plan","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PlanAnalyzer","namespace":"Flow\\PostgreSql\\Explain\\Analyzer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHBsYW4gYW5hbHl6ZXIgZm9yIGFuYWx5emluZyBFWFBMQUlOIHBsYW5zLgogKgogKiBAcGFyYW0gUGxhbiAkcGxhbiBUaGUgZXhlY3V0aW9uIHBsYW4gdG8gYW5hbHl6ZQogKgogKiBAcmV0dXJuIFBsYW5BbmFseXplciBUaGUgYW5hbHl6ZXIgZm9yIGV4dHJhY3RpbmcgaW5zaWdodHMKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":46,"slug":"pgsql-connection","name":"pgsql_connection","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"connectionString","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjb25uZWN0aW9uIHBhcmFtZXRlcnMgZnJvbSBhIGNvbm5lY3Rpb24gc3RyaW5nLgogKgogKiBBY2NlcHRzIGxpYnBxLXN0eWxlIGNvbm5lY3Rpb24gc3RyaW5nczoKICogLSBLZXktdmFsdWUgZm9ybWF0OiAiaG9zdD1sb2NhbGhvc3QgcG9ydD01NDMyIGRibmFtZT1teWRiIHVzZXI9bXl1c2VyIHBhc3N3b3JkPXNlY3JldCIKICogLSBVUkkgZm9ybWF0OiAicG9zdGdyZXNxbDovL3VzZXI6cGFzc3dvcmRAbG9jYWxob3N0OjU0MzIvZGJuYW1lIgogKgogKiBAZXhhbXBsZQogKiAkcGFyYW1zID0gcGdzcWxfY29ubmVjdGlvbignaG9zdD1sb2NhbGhvc3QgZGJuYW1lPW15ZGInKTsKICogJHBhcmFtcyA9IHBnc3FsX2Nvbm5lY3Rpb24oJ3Bvc3RncmVzcWw6Ly91c2VyOnBhc3NAbG9jYWxob3N0L215ZGInKTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":68,"slug":"pgsql-connection-dsn","name":"pgsql_connection_dsn","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"dsn","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjb25uZWN0aW9uIHBhcmFtZXRlcnMgZnJvbSBhIERTTiBzdHJpbmcuCiAqCiAqIFBhcnNlcyBzdGFuZGFyZCBQb3N0Z3JlU1FMIERTTiBmb3JtYXQgY29tbW9ubHkgdXNlZCBpbiBlbnZpcm9ubWVudCB2YXJpYWJsZXMKICogKGUuZy4sIERBVEFCQVNFX1VSTCkuIFN1cHBvcnRzIHBvc3RncmVzOi8vLCBwb3N0Z3Jlc3FsOi8vLCBhbmQgcGdzcWw6Ly8gc2NoZW1lcy4KICoKICogQHBhcmFtIHN0cmluZyAkZHNuIERTTiBzdHJpbmcgaW4gZm9ybWF0OiBwb3N0Z3JlczovL3VzZXI6cGFzc3dvcmRAaG9zdDpwb3J0L2RhdGFiYXNlP29wdGlvbnMKICoKICogQHRocm93cyBDbGllbnRcRHNuUGFyc2VyRXhjZXB0aW9uIElmIHRoZSBEU04gY2Fubm90IGJlIHBhcnNlZAogKgogKiBAZXhhbXBsZQogKiAkcGFyYW1zID0gcGdzcWxfY29ubmVjdGlvbl9kc24oJ3Bvc3RncmVzOi8vbXl1c2VyOnNlY3JldEBsb2NhbGhvc3Q6NTQzMi9teWRiJyk7CiAqICRwYXJhbXMgPSBwZ3NxbF9jb25uZWN0aW9uX2RzbigncG9zdGdyZXNxbDovL3VzZXI6cGFzc0BkYi5leGFtcGxlLmNvbS9hcHA\/c3NsbW9kZT1yZXF1aXJlJyk7CiAqICRwYXJhbXMgPSBwZ3NxbF9jb25uZWN0aW9uX2RzbigncGdzcWw6Ly91c2VyOnBhc3NAbG9jYWxob3N0L215ZGInKTsgLy8gU3ltZm9ueS9Eb2N0cmluZSBmb3JtYXQKICogJHBhcmFtcyA9IHBnc3FsX2Nvbm5lY3Rpb25fZHNuKGdldGVudignREFUQUJBU0VfVVJMJykpOwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":95,"slug":"pgsql-connection-params","name":"pgsql_connection_params","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"database","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'localhost'"},{"name":"port","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"5432"},{"name":"user","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"password","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"options","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjb25uZWN0aW9uIHBhcmFtZXRlcnMgZnJvbSBpbmRpdmlkdWFsIHZhbHVlcy4KICoKICogQWxsb3dzIHNwZWNpZnlpbmcgY29ubmVjdGlvbiBwYXJhbWV0ZXJzIGluZGl2aWR1YWxseSBmb3IgYmV0dGVyIHR5cGUgc2FmZXR5CiAqIGFuZCBJREUgc3VwcG9ydC4KICoKICogQHBhcmFtIHN0cmluZyAkZGF0YWJhc2UgRGF0YWJhc2UgbmFtZSAocmVxdWlyZWQpCiAqIEBwYXJhbSBzdHJpbmcgJGhvc3QgSG9zdG5hbWUgKGRlZmF1bHQ6IGxvY2FsaG9zdCkKICogQHBhcmFtIGludCAkcG9ydCBQb3J0IG51bWJlciAoZGVmYXVsdDogNTQzMikKICogQHBhcmFtIG51bGx8c3RyaW5nICR1c2VyIFVzZXJuYW1lIChvcHRpb25hbCkKICogQHBhcmFtIG51bGx8c3RyaW5nICRwYXNzd29yZCBQYXNzd29yZCAob3B0aW9uYWwpCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIHN0cmluZz4gJG9wdGlvbnMgQWRkaXRpb25hbCBsaWJwcSBvcHRpb25zCiAqCiAqIEBleGFtcGxlCiAqICRwYXJhbXMgPSBwZ3NxbF9jb25uZWN0aW9uX3BhcmFtcygKICogICAgIGRhdGFiYXNlOiAnbXlkYicsCiAqICAgICBob3N0OiAnbG9jYWxob3N0JywKICogICAgIHVzZXI6ICdteXVzZXInLAogKiAgICAgcGFzc3dvcmQ6ICdzZWNyZXQnLAogKiApOwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":126,"slug":"pgsql-client","name":"pgsql_client","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"params","type":[{"name":"ConnectionParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"valueConverters","type":[{"name":"ValueConverters","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"context","type":[{"name":"Context","namespace":"Flow\\PostgreSql\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBvc3RncmVTUUwgY2xpZW50IHVzaW5nIGV4dC1wZ3NxbC4KICoKICogVGhlIGNsaWVudCBjb25uZWN0cyBpbW1lZGlhdGVseSBhbmQgaXMgcmVhZHkgdG8gZXhlY3V0ZSBxdWVyaWVzLgogKgogKiBAcGFyYW0gQ2xpZW50XENvbm5lY3Rpb25QYXJhbWV0ZXJzICRwYXJhbXMgQ29ubmVjdGlvbiBwYXJhbWV0ZXJzCiAqIEBwYXJhbSBudWxsfFZhbHVlQ29udmVydGVycyAkdmFsdWVDb252ZXJ0ZXJzIEN1c3RvbSB0eXBlIGNvbnZlcnRlcnMgKG9wdGlvbmFsKQogKiBAcGFyYW0gbnVsbHxDb250ZXh0ICRjb250ZXh0IEJhc2UgbWFwcGVyIENvbnRleHQg4oCUIHRoZSBDbGllbnQgZW5yaWNoZXMgaXQgd2l0aCBzcWwvcGFyYW1ldGVycy9zZWxmIHBlciBxdWVyeSBiZWZvcmUgaGFuZGluZyBpdCB0byBSb3dNYXBwZXI6Om1hcCgpCiAqCiAqIEB0aHJvd3MgQ29ubmVjdGlvbkV4Y2VwdGlvbiBJZiBjb25uZWN0aW9uIGZhaWxzCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":143,"slug":"postgresql-context","name":"postgresql_context","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"catalog","type":[{"name":"Catalog","namespace":"Flow\\PostgreSql\\Schema","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Context","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJvd01hcHBlciBDb250ZXh0IHNlZWRlZCB3aXRoIHVzZXItc3VwcGxpZWQga2V5L3ZhbHVlIGRhdGEgYW5kIGFuIG9wdGlvbmFsIENhdGFsb2cuCiAqCiAqIFRoZSBDb250ZXh0IGlzIGxhdGVyIGVucmljaGVkIHdpdGggYSBRdWVyeSAoc3FsICsgcGFyYW1ldGVycykgYW5kIHRoZSBleGVjdXRpbmcgQ2xpZW50IGJ5IHRoZQogKiBQb3N0Z3JlU1FMIENsaWVudCBiZWZvcmUgYmVpbmcgaGFuZGVkIHRvIFJvd01hcHBlcjo6bWFwKCkuCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIG1peGVkPiAkZGF0YSBVc2VyLXN1cHBsaWVkIGtleS92YWx1ZSBwYWlycwogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":176,"slug":"postgresql-telemetry-options","name":"postgresql_telemetry_options","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"traceQueries","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"transactionSpans","type":[{"name":"TransactionSpanMode","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\PostgreSql\\Client\\Telemetry\\TransactionSpanMode::..."},{"name":"collectMetrics","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"logQueries","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"maxQueryLength","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"1000"},{"name":"includeParameters","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"maxParameters","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"10"},{"name":"maxParameterLength","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"100"}],"return_type":[{"name":"PostgreSqlTelemetryOptions","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB0ZWxlbWV0cnkgb3B0aW9ucyBmb3IgUG9zdGdyZVNRTCBjbGllbnQgaW5zdHJ1bWVudGF0aW9uLgogKgogKiBDb250cm9scyB3aGljaCB0ZWxlbWV0cnkgc2lnbmFscyAodHJhY2VzLCBtZXRyaWNzLCBsb2dzKSBhcmUgZW5hYmxlZAogKiBhbmQgaG93IHF1ZXJ5IGluZm9ybWF0aW9uIGlzIGNhcHR1cmVkLgogKgogKiBAcGFyYW0gYm9vbCAkdHJhY2VRdWVyaWVzIENyZWF0ZSBzcGFucyBmb3IgcXVlcnkgZXhlY3V0aW9uIChkZWZhdWx0OiB0cnVlKQogKiBAcGFyYW0gVHJhbnNhY3Rpb25TcGFuTW9kZSAkdHJhbnNhY3Rpb25TcGFucyBIb3cgdHJhbnNhY3Rpb25zIGFyZSB0cmFjZWQ6IEdST1VQRUQgKGRlZmF1bHQpLCBQRVJfT1BFUkFUSU9OIG9yIE9GRgogKiBAcGFyYW0gYm9vbCAkY29sbGVjdE1ldHJpY3MgQ29sbGVjdCBkdXJhdGlvbiBhbmQgcm93IGNvdW50IG1ldHJpY3MgKGRlZmF1bHQ6IHRydWUpCiAqIEBwYXJhbSBib29sICRsb2dRdWVyaWVzIExvZyBleGVjdXRlZCBxdWVyaWVzIChkZWZhdWx0OiBmYWxzZSkKICogQHBhcmFtIG51bGx8aW50ICRtYXhRdWVyeUxlbmd0aCBNYXhpbXVtIHF1ZXJ5IHRleHQgbGVuZ3RoIGluIHRlbGVtZXRyeSAoZGVmYXVsdDogMTAwMCwgbnVsbCA9IHVubGltaXRlZCkKICogQHBhcmFtIGJvb2wgJGluY2x1ZGVQYXJhbWV0ZXJzIEluY2x1ZGUgcXVlcnkgcGFyYW1ldGVycyBpbiB0ZWxlbWV0cnkgKGRlZmF1bHQ6IGZhbHNlLCBzZWN1cml0eSBjb25zaWRlcmF0aW9uKQogKgogKiBAZXhhbXBsZQogKiAvLyBEZWZhdWx0IG9wdGlvbnMgKHRyYWNlcyBhbmQgbWV0cmljcyBlbmFibGVkKQogKiAkb3B0aW9ucyA9IHBvc3RncmVzcWxfdGVsZW1ldHJ5X29wdGlvbnMoKTsKICoKICogLy8gRW5hYmxlIHF1ZXJ5IGxvZ2dpbmcKICogJG9wdGlvbnMgPSBwb3N0Z3Jlc3FsX3RlbGVtZXRyeV9vcHRpb25zKGxvZ1F1ZXJpZXM6IHRydWUpOwogKgogKiAvLyBNZXRyaWNzIG9ubHksIG5vIHNwYW5zCiAqICRvcHRpb25zID0gcG9zdGdyZXNxbF90ZWxlbWV0cnlfb3B0aW9ucygKICogICAgIHRyYWNlUXVlcmllczogZmFsc2UsCiAqICAgICB0cmFuc2FjdGlvblNwYW5zOiBUcmFuc2FjdGlvblNwYW5Nb2RlOjpPRkYsCiAqICAgICBjb2xsZWN0TWV0cmljczogdHJ1ZSwKICogKTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":214,"slug":"postgresql-telemetry-config","name":"postgresql_telemetry_config","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"telemetry","type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"PostgreSqlTelemetryOptions","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PostgreSqlTelemetryConfig","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB0ZWxlbWV0cnkgY29uZmlndXJhdGlvbiBmb3IgUG9zdGdyZVNRTCBjbGllbnQuCiAqCiAqIEJ1bmRsZXMgdGVsZW1ldHJ5IGluc3RhbmNlLCBjbG9jaywgYW5kIG9wdGlvbnMgbmVlZGVkIHRvIGluc3RydW1lbnQgYSBQb3N0Z3JlU1FMIGNsaWVudC4KICoKICogQHBhcmFtIFRlbGVtZXRyeSAkdGVsZW1ldHJ5IFRoZSB0ZWxlbWV0cnkgaW5zdGFuY2UKICogQHBhcmFtIENsb2NrSW50ZXJmYWNlICRjbG9jayBDbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gbnVsbHxQb3N0Z3JlU3FsVGVsZW1ldHJ5T3B0aW9ucyAkb3B0aW9ucyBUZWxlbWV0cnkgb3B0aW9ucyAoZGVmYXVsdDogYWxsIGVuYWJsZWQpCiAqCiAqIEBleGFtcGxlCiAqICRjb25maWcgPSBwb3N0Z3Jlc3FsX3RlbGVtZXRyeV9jb25maWcoCiAqICAgICB0ZWxlbWV0cnkocmVzb3VyY2UoWydzZXJ2aWNlLm5hbWUnID0+ICdteS1hcHAnXSkpLAogKiAgICAgbmV3IFN5c3RlbUNsb2NrKCksCiAqICk7CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":260,"slug":"traceable-postgresql-client","name":"traceable_postgresql_client","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"client","type":[{"name":"Client","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"telemetryConfig","type":[{"name":"PostgreSqlTelemetryConfig","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TraceableClient","namespace":"Flow\\PostgreSql\\Client\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYSBQb3N0Z3JlU1FMIGNsaWVudCB3aXRoIHRlbGVtZXRyeSBpbnN0cnVtZW50YXRpb24uCiAqCiAqIFJldHVybnMgYSBkZWNvcmF0b3IgdGhhdCBhZGRzIHNwYW5zLCBtZXRyaWNzLCBhbmQgbG9ncyB0byBhbGwKICogcXVlcnkgYW5kIHRyYW5zYWN0aW9uIG9wZXJhdGlvbnMgZm9sbG93aW5nIE9wZW5UZWxlbWV0cnkgY29udmVudGlvbnMuCiAqCiAqIEBwYXJhbSBDbGllbnRcQ2xpZW50ICRjbGllbnQgVGhlIFBvc3RncmVTUUwgY2xpZW50IHRvIGluc3RydW1lbnQKICogQHBhcmFtIFBvc3RncmVTcWxUZWxlbWV0cnlDb25maWcgJHRlbGVtZXRyeUNvbmZpZyBUZWxlbWV0cnkgY29uZmlndXJhdGlvbgogKgogKiBAZXhhbXBsZQogKiAkY2xpZW50ID0gcGdzcWxfY2xpZW50KHBnc3FsX2Nvbm5lY3Rpb24oJ2hvc3Q9bG9jYWxob3N0IGRibmFtZT1teWRiJykpOwogKgogKiAkdHJhY2VhYmxlQ2xpZW50ID0gdHJhY2VhYmxlX3Bvc3RncmVzcWxfY2xpZW50KAogKiAgICAgJGNsaWVudCwKICogICAgIHBvc3RncmVzcWxfdGVsZW1ldHJ5X2NvbmZpZygKICogICAgICAgICB0ZWxlbWV0cnkocmVzb3VyY2UoWydzZXJ2aWNlLm5hbWUnID0+ICdteS1hcHAnXSkpLAogKiAgICAgICAgIG5ldyBTeXN0ZW1DbG9jaygpLAogKiAgICAgICAgIHBvc3RncmVzcWxfdGVsZW1ldHJ5X29wdGlvbnMoCiAqICAgICAgICAgICAgIHRyYWNlUXVlcmllczogdHJ1ZSwKICogICAgICAgICAgICAgdHJhbnNhY3Rpb25TcGFuczogVHJhbnNhY3Rpb25TcGFuTW9kZTo6R1JPVVBFRCwKICogICAgICAgICAgICAgY29sbGVjdE1ldHJpY3M6IHRydWUsCiAqICAgICAgICAgICAgIGxvZ1F1ZXJpZXM6IHRydWUsCiAqICAgICAgICAgICAgIG1heFF1ZXJ5TGVuZ3RoOiA1MDAsCiAqICAgICAgICAgKSwKICogICAgICksCiAqICk7CiAqCiAqIC8vIEFsbCBvcGVyYXRpb25zIG5vdyB0cmFjZWQKICogJHRyYWNlYWJsZUNsaWVudC0+dHJhbnNhY3Rpb24oZnVuY3Rpb24gKENsaWVudCAkY2xpZW50KSB7CiAqICAgICAkdXNlciA9ICRjbGllbnQtPmZldGNoU2luZ2xlKCdTRUxFQ1QgKiBGUk9NIHVzZXJzIFdIRVJFIGlkID0gJDEnLCBbMTIzXSk7CiAqICAgICAkY2xpZW50LT5leGVjdXRlKCdVUERBVEUgdXNlcnMgU0VUIGxhc3RfbG9naW4gPSBOT1coKSBXSEVSRSBpZCA9ICQxJywgWzEyM10pOwogKiB9KTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":300,"slug":"constructor-mapper","name":"constructor_mapper","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConstructorMapper","namespace":"Flow\\PostgreSql\\Client\\RowMapper","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICRjbGFzcwogKgogKiBAcmV0dXJuIENvbnN0cnVjdG9yTWFwcGVyPFQ+CiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":315,"slug":"type-mapper","name":"type_mapper","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"type","type":[{"name":"Type","namespace":"Flow\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"next","type":[{"name":"RowMapper","namespace":"Flow\\PostgreSql\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TypeMapper","namespace":"Flow\\PostgreSql\\Client\\RowMapper","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0ZW1wbGF0ZSBUVHlwZQogKiBAdGVtcGxhdGUgVE91dAogKgogKiBAcGFyYW0gRmxvd1R5cGU8VFR5cGU+ICR0eXBlCiAqIEBwYXJhbSBudWxsfFJvd01hcHBlcjxUT3V0PiAkbmV4dAogKgogKiBAcmV0dXJuICgkbmV4dCBpcyBudWxsID8gVHlwZU1hcHBlcjxUVHlwZSwgVFR5cGU+IDogVHlwZU1hcHBlcjxUVHlwZSwgVE91dD4pCiAqLw=="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":343,"slug":"static-factory-mapper","name":"static_factory_mapper","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"class","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"method","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"StaticFactoryMapper","namespace":"Flow\\PostgreSql\\Client\\RowMapper","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJvdyBtYXBwZXIgYmFja2VkIGJ5IGEgcHVibGljIHN0YXRpYyBmYWN0b3J5IG1ldGhvZC4KICoKICogVGhlIGZhY3RvcnkgbWV0aG9kIG11c3QgYWNjZXB0IGEgc2luZ2xlIGFycmF5PHN0cmluZywgbWl4ZWQ+ICRyb3cgYW5kIHJldHVybgogKiBhbiBpbnN0YW5jZSBvZiB0aGUgdGFyZ2V0IGNsYXNzLiBJZiB5b3VyIGZhY3RvcnkgbmVlZHMgYWNjZXNzIHRvIHRoZSBtYXBwaW5nCiAqIENvbnRleHQgKHNxbC9wYXJhbWV0ZXJzL2NsaWVudC9jYXRhbG9nL3VzZXItZGF0YSksIGltcGxlbWVudCBSb3dNYXBwZXIgZGlyZWN0bHkuCiAqCiAqIEB0ZW1wbGF0ZSBUIG9mIG9iamVjdAogKgogKiBAcGFyYW0gY2xhc3Mtc3RyaW5nPFQ+ICRjbGFzcwogKiBAcGFyYW0gbm9uLWVtcHR5LXN0cmluZyAkbWV0aG9kCiAqCiAqIEByZXR1cm4gU3RhdGljRmFjdG9yeU1hcHBlcjxUPgogKi8="},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":372,"slug":"typed","name":"typed","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"value","type":[{"name":"mixed","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":false,"is_nullable":true,"is_variadic":false,"default_value":null},{"name":"targetType","type":[{"name":"ValueType","namespace":"Flow\\PostgreSql\\Client\\Types","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TypedValue","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFdyYXAgYSB2YWx1ZSB3aXRoIGV4cGxpY2l0IFBvc3RncmVTUUwgdHlwZSBpbmZvcm1hdGlvbiBmb3IgcGFyYW1ldGVyIGJpbmRpbmcuCiAqCiAqIFVzZSB3aGVuIGF1dG8tZGV0ZWN0aW9uIGlzbid0IHN1ZmZpY2llbnQgb3Igd2hlbiB5b3UgbmVlZCB0byBzcGVjaWZ5CiAqIHRoZSBleGFjdCBQb3N0Z3JlU1FMIHR5cGUgKHNpbmNlIG9uZSBQSFAgdHlwZSBjYW4gbWFwIHRvIG11bHRpcGxlIFBvc3RncmVTUUwgdHlwZXMpOgogKiAtIGludCBjb3VsZCBiZSBJTlQyLCBJTlQ0LCBvciBJTlQ4CiAqIC0gc3RyaW5nIGNvdWxkIGJlIFRFWFQsIFZBUkNIQVIsIG9yIENIQVIKICogLSBhcnJheSBtdXN0IGFsd2F5cyB1c2UgdHlwZWQoKSBzaW5jZSBhdXRvLWRldGVjdGlvbiBjYW5ub3QgZGV0ZXJtaW5lIGVsZW1lbnQgdHlwZQogKiAtIERhdGVUaW1lSW50ZXJmYWNlIGNvdWxkIGJlIFRJTUVTVEFNUCBvciBUSU1FU1RBTVBUWgogKiAtIEpzb24gY291bGQgYmUgSlNPTiBvciBKU09OQgogKgogKiBAcGFyYW0gbWl4ZWQgJHZhbHVlIFRoZSB2YWx1ZSB0byBiaW5kCiAqIEBwYXJhbSBWYWx1ZVR5cGUgJHRhcmdldFR5cGUgVGhlIFBvc3RncmVTUUwgdHlwZSB0byBjb252ZXJ0IHRoZSB2YWx1ZSB0bwogKgogKiBAZXhhbXBsZQogKiAkY2xpZW50LT5mZXRjaCgKICogICAgICdTRUxFQ1QgKiBGUk9NIHVzZXJzIFdIRVJFIGlkID0gJDEgQU5EIHRhZ3MgPSAkMicsCiAqICAgICBbCiAqICAgICAgICAgdHlwZWQoJzU1MGU4NDAwLWUyOWItNDFkNC1hNzE2LTQ0NjY1NTQ0MDAwMCcsIFZhbHVlVHlwZTo6VVVJRCksCiAqICAgICAgICAgdHlwZWQoWyd0YWcxJywgJ3RhZzInXSwgVmFsdWVUeXBlOjpURVhUX0FSUkFZKSwKICogICAgIF0KICogKTsKICov"},{"repository_path":"src\/lib\/postgresql\/src\/Flow\/PostgreSql\/DSL\/client.php","start_line_in_file":386,"slug":"converted-parameters","name":"converted_parameters","namespace":"Flow\\PostgreSql\\DSL","parameters":[{"name":"values","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ConvertedParameters","namespace":"Flow\\PostgreSql\\Client","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PG_QUERY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIFBhcmFtZXRlcnMgYWxyZWFkeSBpbiBQb3N0Z3JlU1FMJ3MgdGV4dCBmb3JtLCB3aGljaCBDbGllbnQ6OmV4ZWN1dGUoKSBzZW5kcyB3aXRob3V0IHJ1bm5pbmcgYSBjb252ZXJ0ZXIuCiAqCiAqIEBwYXJhbSBsaXN0PG51bGx8c3RyaW5nPiAkdmFsdWVzCiAqCiAqIEBleGFtcGxlCiAqICRjbGllbnQtPmV4ZWN1dGUoJ1VQREFURSB1c2VycyBTRVQgYWN0aXZlID0gJDEgV0hFUkUgaWQgPSAkMicsIGNvbnZlcnRlZF9wYXJhbWV0ZXJzKFsnZicsICcxJ10pKTsKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":126,"slug":"trace-id","name":"trace_id","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"hex","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"TraceId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlSWQuCiAqCiAqIElmIGEgaGV4IHN0cmluZyBpcyBwcm92aWRlZCwgY3JlYXRlcyBhIFRyYWNlSWQgZnJvbSBpdC4KICogT3RoZXJ3aXNlLCBnZW5lcmF0ZXMgYSBuZXcgcmFuZG9tIFRyYWNlSWQuCiAqCiAqIEBwYXJhbSBudWxsfHN0cmluZyAkaGV4IE9wdGlvbmFsIDMyLWNoYXJhY3RlciBoZXhhZGVjaW1hbCBzdHJpbmcKICoKICogQHRocm93cyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBoZXggc3RyaW5nIGlzIGludmFsaWQKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":146,"slug":"span-id","name":"span_id","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"hex","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SpanId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5JZC4KICoKICogSWYgYSBoZXggc3RyaW5nIGlzIHByb3ZpZGVkLCBjcmVhdGVzIGEgU3BhbklkIGZyb20gaXQuCiAqIE90aGVyd2lzZSwgZ2VuZXJhdGVzIGEgbmV3IHJhbmRvbSBTcGFuSWQuCiAqCiAqIEBwYXJhbSBudWxsfHN0cmluZyAkaGV4IE9wdGlvbmFsIDE2LWNoYXJhY3RlciBoZXhhZGVjaW1hbCBzdHJpbmcKICoKICogQHRocm93cyBcSW52YWxpZEFyZ3VtZW50RXhjZXB0aW9uIGlmIHRoZSBoZXggc3RyaW5nIGlzIGludmFsaWQKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":161,"slug":"baggage","name":"baggage","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"entries","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Baggage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhZ2dhZ2UuCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIHN0cmluZz4gJGVudHJpZXMgSW5pdGlhbCBrZXktdmFsdWUgZW50cmllcwogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":175,"slug":"context","name":"context","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"baggage","type":[{"name":"Baggage","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Context","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJvb3QgQ29udGV4dCAobm8gYWN0aXZlIHNwYW4pLgogKgogKiBBIHNwYW4gY3JlYXRlZCBpbiB0aGlzIGNvbnRleHQgYmVjb21lcyBhIG5ldyB0cmFjZSByb290LiBBdHRhY2ggYW4gYWN0aXZlIHNwYW4gd2l0aAogKiBDb250ZXh0Ojp3aXRoQWN0aXZlU3BhbigpIHRvIG1ha2Ugc3Vic2VxdWVudCBzcGFucyBpdHMgY2hpbGRyZW4uCiAqCiAqIEBwYXJhbSBudWxsfEJhZ2dhZ2UgJGJhZ2dhZ2UgT3B0aW9uYWwgQmFnZ2FnZSB0byB1c2UKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":189,"slug":"memory-context-storage","name":"memory_context_storage","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"context","type":[{"name":"Context","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MemoryContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeUNvbnRleHRTdG9yYWdlLgogKgogKiBJbi1tZW1vcnkgY29udGV4dCBzdG9yYWdlIGZvciBzdG9yaW5nIGFuZCByZXRyaWV2aW5nIHRoZSBjdXJyZW50IGNvbnRleHQuCiAqIEEgc2luZ2xlIGluc3RhbmNlIHNob3VsZCBiZSBzaGFyZWQgYWNyb3NzIGFsbCBwcm92aWRlcnMgd2l0aGluIGEgcmVxdWVzdCBsaWZlY3ljbGUuCiAqCiAqIEBwYXJhbSBudWxsfENvbnRleHQgJGNvbnRleHQgT3B0aW9uYWwgaW5pdGlhbCBjb250ZXh0CiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":200,"slug":"resource","name":"resource","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"Resource","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFJlc291cmNlLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBhcnJheTxhcnJheS1rZXksIG1peGVkPnxib29sfFxEYXRlVGltZUludGVyZmFjZXxmbG9hdHxpbnR8c3RyaW5nfFxUaHJvd2FibGU+fEF0dHJpYnV0ZXMgJGF0dHJpYnV0ZXMgUmVzb3VyY2UgYXR0cmlidXRlcwogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":213,"slug":"span-context","name":"span_context","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"traceId","type":[{"name":"TraceId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"spanId","type":[{"name":"SpanId","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"parentSpanId","type":[{"name":"SpanId","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SpanContext","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5Db250ZXh0LgogKgogKiBAcGFyYW0gVHJhY2VJZCAkdHJhY2VJZCBUaGUgdHJhY2UgSUQKICogQHBhcmFtIFNwYW5JZCAkc3BhbklkIFRoZSBzcGFuIElECiAqIEBwYXJhbSBudWxsfFNwYW5JZCAkcGFyZW50U3BhbklkIE9wdGlvbmFsIHBhcmVudCBzcGFuIElECiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":226,"slug":"span-event","name":"span_event","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"timestamp","type":[{"name":"DateTimeImmutable","namespace":"","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"GenericEvent","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5FdmVudCAoR2VuZXJpY0V2ZW50KSB3aXRoIGFuIGV4cGxpY2l0IHRpbWVzdGFtcC4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBFdmVudCBuYW1lCiAqIEBwYXJhbSBcRGF0ZVRpbWVJbW11dGFibGUgJHRpbWVzdGFtcCBFdmVudCB0aW1lc3RhbXAKICogQHBhcmFtIGFycmF5PHN0cmluZywgYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58Ym9vbHxcRGF0ZVRpbWVJbnRlcmZhY2V8ZmxvYXR8aW50fHN0cmluZ3xcVGhyb3dhYmxlPnxBdHRyaWJ1dGVzICRhdHRyaWJ1dGVzIEV2ZW50IGF0dHJpYnV0ZXMKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":238,"slug":"span-link","name":"span_link","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"context","type":[{"name":"SpanContext","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"SpanLink","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNwYW5MaW5rLgogKgogKiBAcGFyYW0gU3BhbkNvbnRleHQgJGNvbnRleHQgVGhlIGxpbmtlZCBzcGFuIGNvbnRleHQKICogQHBhcmFtIGFycmF5PHN0cmluZywgYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58Ym9vbHxcRGF0ZVRpbWVJbnRlcmZhY2V8ZmxvYXR8aW50fHN0cmluZ3xcVGhyb3dhYmxlPnxBdHRyaWJ1dGVzICRhdHRyaWJ1dGVzIExpbmsgYXR0cmlidXRlcwogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":254,"slug":"span-limits","name":"span_limits","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributeCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"eventCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"linkCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributePerEventCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributePerLinkCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributeValueLengthLimit","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SpanLimits","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBTcGFuTGltaXRzIGNvbmZpZ3VyYXRpb24uCiAqCiAqIEBwYXJhbSBpbnQgJGF0dHJpYnV0ZUNvdW50TGltaXQgTWF4aW11bSBudW1iZXIgb2YgYXR0cmlidXRlcyBwZXIgc3BhbgogKiBAcGFyYW0gaW50ICRldmVudENvdW50TGltaXQgTWF4aW11bSBudW1iZXIgb2YgZXZlbnRzIHBlciBzcGFuCiAqIEBwYXJhbSBpbnQgJGxpbmtDb3VudExpbWl0IE1heGltdW0gbnVtYmVyIG9mIGxpbmtzIHBlciBzcGFuCiAqIEBwYXJhbSBpbnQgJGF0dHJpYnV0ZVBlckV2ZW50Q291bnRMaW1pdCBNYXhpbXVtIG51bWJlciBvZiBhdHRyaWJ1dGVzIHBlciBldmVudAogKiBAcGFyYW0gaW50ICRhdHRyaWJ1dGVQZXJMaW5rQ291bnRMaW1pdCBNYXhpbXVtIG51bWJlciBvZiBhdHRyaWJ1dGVzIHBlciBsaW5rCiAqIEBwYXJhbSBudWxsfGludCAkYXR0cmlidXRlVmFsdWVMZW5ndGhMaW1pdCBNYXhpbXVtIGxlbmd0aCBmb3Igc3RyaW5nIGF0dHJpYnV0ZSB2YWx1ZXMgKG51bGwgPSB1bmxpbWl0ZWQpCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":279,"slug":"log-record-limits","name":"log_record_limits","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributeCountLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"128"},{"name":"attributeValueLengthLimit","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"LogRecordLimits","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBMb2dSZWNvcmRMaW1pdHMgY29uZmlndXJhdGlvbi4KICoKICogQHBhcmFtIGludCAkYXR0cmlidXRlQ291bnRMaW1pdCBNYXhpbXVtIG51bWJlciBvZiBhdHRyaWJ1dGVzIHBlciBsb2cgcmVjb3JkCiAqIEBwYXJhbSBudWxsfGludCAkYXR0cmlidXRlVmFsdWVMZW5ndGhMaW1pdCBNYXhpbXVtIGxlbmd0aCBmb3Igc3RyaW5nIGF0dHJpYnV0ZSB2YWx1ZXMgKG51bGwgPSB1bmxpbWl0ZWQpCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":290,"slug":"metric-limits","name":"metric_limits","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"cardinalityLimit","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"2000"}],"return_type":[{"name":"MetricLimits","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBNZXRyaWNMaW1pdHMgY29uZmlndXJhdGlvbi4KICoKICogQHBhcmFtIGludCAkY2FyZGluYWxpdHlMaW1pdCBNYXhpbXVtIG51bWJlciBvZiB1bmlxdWUgYXR0cmlidXRlIGNvbWJpbmF0aW9ucyBwZXIgaW5zdHJ1bWVudAogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":301,"slug":"void-span-processor","name":"void_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidSpanProcessor","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRTcGFuUHJvY2Vzc29yLgogKgogKiBOby1vcCBzcGFuIHByb2Nlc3NvciB0aGF0IGRpc2NhcmRzIGFsbCBkYXRhLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":312,"slug":"void-metric-processor","name":"void_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidMetricProcessor","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRNZXRyaWNQcm9jZXNzb3IuCiAqCiAqIE5vLW9wIG1ldHJpYyBwcm9jZXNzb3IgdGhhdCBkaXNjYXJkcyBhbGwgZGF0YS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":323,"slug":"void-log-processor","name":"void_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidLogProcessor","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRMb2dQcm9jZXNzb3IuCiAqCiAqIE5vLW9wIGxvZyBwcm9jZXNzb3IgdGhhdCBkaXNjYXJkcyBhbGwgZGF0YS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":334,"slug":"void-exporter","name":"void_exporter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"VoidExporter","namespace":"Flow\\Telemetry\\Provider\\Void","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZvaWRFeHBvcnRlci4KICoKICogTm8tb3AgdW5pZmllZCBleHBvcnRlciB0aGF0IGRpc2NhcmRzIGxvZ3MsIG1ldHJpY3MsIGFuZCBzcGFucy4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":348,"slug":"memory-exporter","name":"memory_exporter","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"maxEntriesPerSignal","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"MemoryExporter","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeUV4cG9ydGVyLgogKgogKiBVbmlmaWVkIGV4cG9ydGVyIHRoYXQgc3RvcmVzIGxvZ3MsIG1ldHJpY3MsIGFuZCBzcGFucyBpbiBtZW1vcnkgZm9yIGRpcmVjdCBhY2Nlc3MuCiAqIFVzZWZ1bCBmb3IgdGVzdGluZyBhbmQgaW5zcGVjdGlvbiB3aXRob3V0IHNlcmlhbGl6YXRpb24uCiAqCiAqIEBwYXJhbSBudWxsfGludCAkbWF4RW50cmllc1BlclNpZ25hbCBtYXhpbXVtIGVudHJpZXMgcmV0YWluZWQgcGVyIHNpZ25hbCB0eXBlOyBudWxsIGtlZXBzIGV2ZXJ5dGhpbmcKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":360,"slug":"memory-span-processor","name":"memory_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MemorySpanProcessor","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeVNwYW5Qcm9jZXNzb3IuCiAqCiAqIEBwYXJhbSBFeHBvcnRlciAkZXhwb3J0ZXIgVGhlIGV4cG9ydGVyIHRvIHNlbmQgc3BhbnMgdG8KICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBleHBvcnRlcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":374,"slug":"memory-metric-processor","name":"memory_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MemoryMetricProcessor","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeU1ldHJpY1Byb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBtZXRyaWNzIHRvCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":388,"slug":"memory-log-processor","name":"memory_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MemoryLogProcessor","namespace":"Flow\\Telemetry\\Provider\\Memory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1lbW9yeUxvZ1Byb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBsb2dzIHRvCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":406,"slug":"tracer-provider","name":"tracer_provider","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"SpanProcessor","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sampler","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\ParentBasedSampler::..."},{"name":"limits","type":[{"name":"SpanLimits","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\SpanLimits::..."},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"TracerProvider","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlclByb3ZpZGVyLgogKgogKiBAcGFyYW0gU3BhblByb2Nlc3NvciAkcHJvY2Vzc29yIFRoZSBwcm9jZXNzb3IgZm9yIHNwYW5zCiAqIEBwYXJhbSBDbG9ja0ludGVyZmFjZSAkY2xvY2sgVGhlIGNsb2NrIGZvciB0aW1lc3RhbXBzCiAqIEBwYXJhbSBDb250ZXh0U3RvcmFnZSAkY29udGV4dFN0b3JhZ2UgU3RvcmFnZSBmb3IgY29udGV4dCBwcm9wYWdhdGlvbgogKiBAcGFyYW0gU2FtcGxlciAkc2FtcGxlciBTYW1wbGluZyBzdHJhdGVneSBmb3Igc3BhbnMKICogQHBhcmFtIFNwYW5MaW1pdHMgJGxpbWl0cyBMaW1pdHMgZm9yIHNwYW4gYXR0cmlidXRlcywgZXZlbnRzLCBhbmQgbGlua3MKICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIHJ1bnRpbWUgVGhyb3dhYmxlcyByYWlzZWQgYnkgdGhlIHByb2Nlc3NvcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":427,"slug":"logger-provider","name":"logger_provider","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"LogProcessor","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"limits","type":[{"name":"LogRecordLimits","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Logger\\LogRecordLimits::..."},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"LoggerProvider","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExvZ2dlclByb3ZpZGVyLgogKgogKiBAcGFyYW0gTG9nUHJvY2Vzc29yICRwcm9jZXNzb3IgVGhlIHByb2Nlc3NvciBmb3IgbG9ncwogKiBAcGFyYW0gQ2xvY2tJbnRlcmZhY2UgJGNsb2NrIFRoZSBjbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gQ29udGV4dFN0b3JhZ2UgJGNvbnRleHRTdG9yYWdlIFN0b3JhZ2UgZm9yIHNwYW4gY29ycmVsYXRpb24KICogQHBhcmFtIExvZ1JlY29yZExpbWl0cyAkbGltaXRzIExpbWl0cyBmb3IgbG9nIHJlY29yZCBhdHRyaWJ1dGVzCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBydW50aW1lIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBwcm9jZXNzb3IKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":448,"slug":"meter-provider","name":"meter_provider","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"MetricProcessor","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"temporality","type":[{"name":"AggregationTemporality","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\AggregationTemporality::..."},{"name":"exemplarFilter","type":[{"name":"ExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\Exemplar\\TraceBasedExemplarFilter::..."},{"name":"limits","type":[{"name":"MetricLimits","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\MetricLimits::..."},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"MeterProvider","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1ldGVyUHJvdmlkZXIuCiAqCiAqIEBwYXJhbSBNZXRyaWNQcm9jZXNzb3IgJHByb2Nlc3NvciBUaGUgcHJvY2Vzc29yIGZvciBtZXRyaWNzCiAqIEBwYXJhbSBDbG9ja0ludGVyZmFjZSAkY2xvY2sgVGhlIGNsb2NrIGZvciB0aW1lc3RhbXBzCiAqIEBwYXJhbSBBZ2dyZWdhdGlvblRlbXBvcmFsaXR5ICR0ZW1wb3JhbGl0eSBBZ2dyZWdhdGlvbiB0ZW1wb3JhbGl0eSBmb3IgbWV0cmljcwogKiBAcGFyYW0gRXhlbXBsYXJGaWx0ZXIgJGV4ZW1wbGFyRmlsdGVyIEZpbHRlciBmb3IgZXhlbXBsYXIgc2FtcGxpbmcgKGRlZmF1bHQ6IFRyYWNlQmFzZWRFeGVtcGxhckZpbHRlcikKICogQHBhcmFtIE1ldHJpY0xpbWl0cyAkbGltaXRzIENhcmRpbmFsaXR5IGxpbWl0cyBmb3IgbWV0cmljIGluc3RydW1lbnRzCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBydW50aW1lIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBwcm9jZXNzb3IKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":471,"slug":"telemetry","name":"telemetry","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"resource","type":[{"name":"Resource","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"tracerProvider","type":[{"name":"TracerProvider","namespace":"Flow\\Telemetry\\Tracer","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"meterProvider","type":[{"name":"MeterProvider","namespace":"Flow\\Telemetry\\Meter","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"loggerProvider","type":[{"name":"LoggerProvider","namespace":"Flow\\Telemetry\\Logger","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG5ldyBUZWxlbWV0cnkgaW5zdGFuY2Ugd2l0aCB0aGUgZ2l2ZW4gcHJvdmlkZXJzLgogKgogKiBJZiBwcm92aWRlcnMgYXJlIG5vdCBzcGVjaWZpZWQsIHZvaWQgcHJvdmlkZXJzIChuby1vcCkgYXJlIHVzZWQuCiAqCiAqIEBwYXJhbSBcRmxvd1xUZWxlbWV0cnlcUmVzb3VyY2UgJHJlc291cmNlIFRoZSByZXNvdXJjZSBkZXNjcmliaW5nIHRoZSBlbnRpdHkgcHJvZHVjaW5nIHRlbGVtZXRyeQogKiBAcGFyYW0gbnVsbHxUcmFjZXJQcm92aWRlciAkdHJhY2VyUHJvdmlkZXIgVGhlIHRyYWNlciBwcm92aWRlciAobnVsbCBmb3Igdm9pZC9kaXNhYmxlZCkKICogQHBhcmFtIG51bGx8TWV0ZXJQcm92aWRlciAkbWV0ZXJQcm92aWRlciBUaGUgbWV0ZXIgcHJvdmlkZXIgKG51bGwgZm9yIHZvaWQvZGlzYWJsZWQpCiAqIEBwYXJhbSBudWxsfExvZ2dlclByb3ZpZGVyICRsb2dnZXJQcm92aWRlciBUaGUgbG9nZ2VyIHByb3ZpZGVyIChudWxsIGZvciB2b2lkL2Rpc2FibGVkKQogKiBAcGFyYW0gRXJyb3JIYW5kbGVyICRlcnJvckhhbmRsZXIgSGFuZGxlciBwcm9wYWdhdGVkIHRvIGRlZmF1bHQgdm9pZCBwcm92aWRlcnMgd2hlbiBleHBsaWNpdCBvbmVzIGFyZSBub3Qgc3VwcGxpZWQKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":507,"slug":"instrumentation-scope","name":"instrumentation_scope","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"name","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"version","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'unknown'"},{"name":"schemaUrl","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Attributes::..."}],"return_type":[{"name":"InstrumentationScope","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBJbnN0cnVtZW50YXRpb25TY29wZS4KICoKICogQHBhcmFtIHN0cmluZyAkbmFtZSBUaGUgaW5zdHJ1bWVudGF0aW9uIHNjb3BlIG5hbWUKICogQHBhcmFtIHN0cmluZyAkdmVyc2lvbiBUaGUgaW5zdHJ1bWVudGF0aW9uIHNjb3BlIHZlcnNpb24KICogQHBhcmFtIG51bGx8c3RyaW5nICRzY2hlbWFVcmwgT3B0aW9uYWwgc2NoZW1hIFVSTAogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":524,"slug":"batching-span-processor","name":"batching_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"batchSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"512"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"BatchingSpanProcessor","namespace":"Flow\\Telemetry\\Tracer\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhdGNoaW5nU3BhblByb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBzcGFucyB0bwogKiBAcGFyYW0gaW50ICRiYXRjaFNpemUgTnVtYmVyIG9mIHNwYW5zIHRvIGNvbGxlY3QgYmVmb3JlIGV4cG9ydGluZyAoZGVmYXVsdCA1MTIpCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":539,"slug":"pass-through-span-processor","name":"pass_through_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"PassThroughSpanProcessor","namespace":"Flow\\Telemetry\\Tracer\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhc3NUaHJvdWdoU3BhblByb2Nlc3Nvci4KICoKICogQHBhcmFtIEV4cG9ydGVyICRleHBvcnRlciBUaGUgZXhwb3J0ZXIgdG8gc2VuZCBzcGFucyB0bwogKiBAcGFyYW0gRXJyb3JIYW5kbGVyICRlcnJvckhhbmRsZXIgSGFuZGxlciBmb3IgVGhyb3dhYmxlcyByYWlzZWQgYnkgdGhlIGV4cG9ydGVyCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":554,"slug":"batching-metric-processor","name":"batching_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"batchSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"512"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"BatchingMetricProcessor","namespace":"Flow\\Telemetry\\Meter\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhdGNoaW5nTWV0cmljUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIG1ldHJpY3MgdG8KICogQHBhcmFtIGludCAkYmF0Y2hTaXplIE51bWJlciBvZiBtZXRyaWNzIHRvIGNvbGxlY3QgYmVmb3JlIGV4cG9ydGluZyAoZGVmYXVsdCA1MTIpCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":569,"slug":"pass-through-metric-processor","name":"pass_through_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"PassThroughMetricProcessor","namespace":"Flow\\Telemetry\\Meter\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhc3NUaHJvdWdoTWV0cmljUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIG1ldHJpY3MgdG8KICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBleHBvcnRlcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":584,"slug":"batching-log-processor","name":"batching_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"batchSize","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"512"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"BatchingLogProcessor","namespace":"Flow\\Telemetry\\Logger\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEJhdGNoaW5nTG9nUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIGxvZ3MgdG8KICogQHBhcmFtIGludCAkYmF0Y2hTaXplIE51bWJlciBvZiBsb2dzIHRvIGNvbGxlY3QgYmVmb3JlIGV4cG9ydGluZyAoZGVmYXVsdCA1MTIpCiAqIEBwYXJhbSBFcnJvckhhbmRsZXIgJGVycm9ySGFuZGxlciBIYW5kbGVyIGZvciBUaHJvd2FibGVzIHJhaXNlZCBieSB0aGUgZXhwb3J0ZXIKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":599,"slug":"pass-through-log-processor","name":"pass_through_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"exporter","type":[{"name":"Exporter","namespace":"Flow\\Telemetry\\Exporter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"PassThroughLogProcessor","namespace":"Flow\\Telemetry\\Logger\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhc3NUaHJvdWdoTG9nUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gRXhwb3J0ZXIgJGV4cG9ydGVyIFRoZSBleHBvcnRlciB0byBzZW5kIGxvZ3MgdG8KICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JIYW5kbGVyIEhhbmRsZXIgZm9yIFRocm93YWJsZXMgcmFpc2VkIGJ5IHRoZSBleHBvcnRlcgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":614,"slug":"pipeline-log-processor","name":"pipeline_log_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"middleware","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sink","type":[{"name":"LogSink","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PipelineLogProcessor","namespace":"Flow\\Telemetry\\Logger\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBpcGVsaW5lTG9nUHJvY2Vzc29yOiBydW4gZWFjaCBsb2cgZW50cnkgdGhyb3VnaCBhbiBvcmRlcmVkIGNoYWluIG9mCiAqIG1pZGRsZXdhcmUsIHRoZW4gZm9yd2FyZCB0aGUgc3Vydml2b3JzIHRvIGEgc2luZ2xlIHNpbmsuCiAqCiAqIEBwYXJhbSBsaXN0PExvZ01pZGRsZXdhcmU+ICRtaWRkbGV3YXJlIHJ1biBpbiBvcmRlcjsgdGhlIGZpcnN0IHRvIGRyb3AgYW4gZW50cnkgc2hvcnQtY2lyY3VpdHMgdGhlIHJlc3QKICogQHBhcmFtIExvZ1NpbmsgJHNpbmsgdGhlIHRlcm1pbmFsIHByb2Nlc3NvciB0aGF0IGV4cG9ydHMgc3Vydml2aW5nIGVudHJpZXMKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":626,"slug":"enriching-log-middleware","name":"enriching_log_middleware","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributes","type":[{"name":"Attributes","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false},{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"EnrichingLogMiddleware","namespace":"Flow\\Telemetry\\Logger\\Middleware","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFbnJpY2hpbmdMb2dNaWRkbGV3YXJlIHRoYXQgbWVyZ2VzIGRlZmF1bHQgYXR0cmlidXRlcyBpbnRvIGV2ZXJ5IGxvZwogKiBlbnRyeS4gQXR0cmlidXRlcyBzZXQgYXQgdGhlIGNhbGwgc2l0ZSB3aW4gb3ZlciB0aGVzZSBkZWZhdWx0cy4KICoKICogQHBhcmFtIGFycmF5PHN0cmluZywgYXJyYXk8YXJyYXkta2V5LCBtaXhlZD58Ym9vbHxcRGF0ZVRpbWVJbnRlcmZhY2V8ZmxvYXR8aW50fHN0cmluZ3xcVGhyb3dhYmxlPnxBdHRyaWJ1dGVzICRhdHRyaWJ1dGVzCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":637,"slug":"attribute-filtering-log-middleware","name":"attribute_filtering_log_middleware","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AttributeFilteringLogMiddleware","namespace":"Flow\\Telemetry\\Logger\\Middleware","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXJpbmdMb2dNaWRkbGV3YXJlIHRoYXQgZHJvcHMgbG9nIGVudHJpZXMgbWF0Y2hpbmcgdGhlIGZpbHRlci4KICoKICogQHBhcmFtIEF0dHJpYnV0ZUZpbHRlciAkZmlsdGVyIFRoZSBhdHRyaWJ1dGUgZmlsdGVyIHRvIGFwcGx5CiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":648,"slug":"severity-filtering-log-middleware","name":"severity_filtering_log_middleware","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"minimumSeverity","type":[{"name":"Severity","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Logger\\Severity::..."}],"return_type":[{"name":"SeverityFilteringLogMiddleware","namespace":"Flow\\Telemetry\\Logger\\Middleware","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNldmVyaXR5RmlsdGVyaW5nTG9nTWlkZGxld2FyZSB0aGF0IGRyb3BzIGxvZyBlbnRyaWVzIGJlbG93IGEgbWluaW11bSBzZXZlcml0eS4KICoKICogQHBhcmFtIFNldmVyaXR5ICRtaW5pbXVtU2V2ZXJpdHkgTWluaW11bSBzZXZlcml0eSBsZXZlbCAoZGVmYXVsdDogSU5GTykKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":662,"slug":"attribute-rule","name":"attribute_rule","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"path","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"mode","type":[{"name":"MatchMode","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"expected","type":[{"name":"DateTimeInterface","namespace":"","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false},{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"caseSensitive","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"AttributeRule","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHNpbmdsZSBhdHRyaWJ1dGUtbWF0Y2hpbmcgcnVsZSBmb3IgYW4gQXR0cmlidXRlRmlsdGVyLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nPnxzdHJpbmcgJHBhdGggYXR0cmlidXRlIHBhdGg6IGEgdG9wLWxldmVsIGtleSwgb3Igc2VnbWVudHMgZGVzY2VuZGluZyBpbnRvIG5lc3RlZCBhcnJheSB2YWx1ZXMKICogQHBhcmFtIE1hdGNoTW9kZSAkbW9kZSBjb21wYXJpc29uIGFwcGxpZWQgYmV0d2VlbiB0aGUgdmFsdWUgYXQgdGhlIHBhdGggYW5kIHRoZSBleHBlY3RlZCB2YWx1ZQogKiBAcGFyYW0gYm9vbHxEYXRlVGltZUludGVyZmFjZXxmbG9hdHxpbnR8c3RyaW5nICRleHBlY3RlZCBleHBlY3RlZCB2YWx1ZSAobXVzdCBiZSBhIHN0cmluZyBmb3IgdGhlIHBhdHRlcm4gbW9kZXMpCiAqIEBwYXJhbSBib29sICRjYXNlU2Vuc2l0aXZlIGFwcGxpZXMgdG8gdGhlIHN1YnN0cmluZyBtb2RlcyBvbmx5IChTVEFSVFNfV0lUSCwgRU5EU19XSVRILCBDT05UQUlOUykKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":675,"slug":"all","name":"all","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matchers","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"All","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgbWF0Y2hlcnMgc28gdGhhdCBldmVyeSBvbmUgbXVzdCBtYXRjaCAobG9naWNhbCBBTkQpLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":684,"slug":"any","name":"any","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matchers","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"Any","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENvbWJpbmUgbWF0Y2hlcnMgc28gdGhhdCBhdCBsZWFzdCBvbmUgbXVzdCBtYXRjaCAobG9naWNhbCBPUikuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":693,"slug":"not","name":"not","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matcher","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Not","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIE5lZ2F0ZSBhIG1hdGNoZXIgKGxvZ2ljYWwgTk9UKS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":712,"slug":"attribute-filter","name":"attribute_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"matcher","type":[{"name":"Matcher","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"exclude","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"sources","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[...]"},{"name":"cacheDir","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"cacheDirPermissions","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"448"}],"return_type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXIgZnJvbSBhIG1hdGNoZXIuCiAqCiAqIEBwYXJhbSBNYXRjaGVyICRtYXRjaGVyIHRoZSBtYXRjaGVyIHRvIGV2YWx1YXRlIGFnYWluc3QgYSBzaWduYWwncyBhdHRyaWJ1dGVzIChjb21wb3NlIHdpdGggYWxsKCksIGFueSgpLCBub3QoKSkKICogQHBhcmFtIGJvb2wgJGV4Y2x1ZGUgd2hlbiB0cnVlIChkZWZhdWx0KSBhIG1hdGNoIGRyb3BzIHRoZSBzaWduYWw7IHdoZW4gZmFsc2Ugb25seSBtYXRjaGluZyBzaWduYWxzIGFyZSBrZXB0CiAqIEBwYXJhbSBsaXN0PEF0dHJpYnV0ZVNvdXJjZT4gJHNvdXJjZXMgd2hpY2ggYXR0cmlidXRlIHNldHMgdG8gaW5zcGVjdCAoc2lnbmFsLCByZXNvdXJjZSBhbmQvb3Igc2NvcGUpOyB0aGUgbWF0Y2hlciBpcwogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE9SLWNvbWJpbmVkIGFjcm9zcyB0aGVtLCBkZWZhdWx0aW5nIHRvIHRoZSBzaWduYWwncyBvd24gYXR0cmlidXRlcwogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJGNhY2hlRGlyIGRpcmVjdG9yeSBmb3IgdGhlIGdlbmVyYXRlZCBtYXRjaGVyIGZpbGUgKGRlZmF1bHRzIHRvIHRoZSBzeXN0ZW0gdGVtcCBkaXJlY3RvcnkpLiBJdCBpcwogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGByZXF1aXJlYGQsIHNvIGl0IE1VU1QgYmUgdHJ1c3RlZCAtIG5vdCB3cml0YWJsZSBieSB1bnRydXN0ZWQgdXNlcnMuIFByZWZlciBhbgogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFwcGxpY2F0aW9uLXByaXZhdGUgZGlyZWN0b3J5IG92ZXIgdGhlIHNoYXJlZCBzeXN0ZW0gdGVtcCBpbiBtdWx0aS10ZW5hbnQgZW52aXJvbm1lbnRzLgogKiBAcGFyYW0gaW50ICRjYWNoZURpclBlcm1pc3Npb25zIG1vZGUgYXBwbGllZCB3aGVuIHRoZSBjYWNoZSBkaXJlY3RvcnkgaXMgY3JlYXRlZCAob2N0YWwsIHN1YmplY3QgdG8gdW1hc2s7IGRlZmF1bHRzCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdG8gMDcwMCAtIG93bmVyIG9ubHksIHNpbmNlIHRoZSBkaXJlY3RvcnkgaG9sZHMgYHJlcXVpcmVgZCBQSFApCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":729,"slug":"attribute-filtering-metric-processor","name":"attribute_filtering_metric_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"MetricProcessor","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AttributeFilteringMetricProcessor","namespace":"Flow\\Telemetry\\Meter\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXJpbmdNZXRyaWNQcm9jZXNzb3IuCiAqCiAqIEBwYXJhbSBNZXRyaWNQcm9jZXNzb3IgJHByb2Nlc3NvciBUaGUgcHJvY2Vzc29yIHRvIHdyYXAKICogQHBhcmFtIEF0dHJpYnV0ZUZpbHRlciAkZmlsdGVyIFRoZSBhdHRyaWJ1dGUgZmlsdGVyIHRvIGFwcGx5CiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":743,"slug":"attribute-filtering-span-processor","name":"attribute_filtering_span_processor","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"processor","type":[{"name":"SpanProcessor","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"AttributeFilteringSpanProcessor","namespace":"Flow\\Telemetry\\Tracer\\Processor","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVGaWx0ZXJpbmdTcGFuUHJvY2Vzc29yLgogKgogKiBAcGFyYW0gU3BhblByb2Nlc3NvciAkcHJvY2Vzc29yIFRoZSBwcm9jZXNzb3IgdG8gd3JhcAogKiBAcGFyYW0gQXR0cmlidXRlRmlsdGVyICRmaWx0ZXIgVGhlIGF0dHJpYnV0ZSBmaWx0ZXIgdG8gYXBwbHkKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":762,"slug":"console-exporter","name":"console_exporter","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"colors","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"maxLogBodyLength","type":[{"name":"int","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"100"},{"name":"logOptions","type":[{"name":"ConsoleLogOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Provider\\Console\\ConsoleLogOptions::..."},{"name":"metricOptions","type":[{"name":"ConsoleMetricOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Provider\\Console\\ConsoleMetricOptions::..."},{"name":"spanOptions","type":[{"name":"ConsoleSpanOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Provider\\Console\\ConsoleSpanOptions::..."}],"return_type":[{"name":"ConsoleExporter","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHVuaWZpZWQgQ29uc29sZUV4cG9ydGVyIGZvciBsb2dzLCBtZXRyaWNzLCBhbmQgc3BhbnMuCiAqCiAqIE91dHB1dHMgdGVsZW1ldHJ5IHRvIHRoZSBjb25zb2xlIHdpdGggQVNDSUkgdGFibGUgZm9ybWF0dGluZyBhbmQgb3B0aW9uYWwgQU5TSSBjb2xvcnMuCiAqCiAqIEBwYXJhbSBib29sICRjb2xvcnMgV2hldGhlciB0byB1c2UgQU5TSSBjb2xvcnMgKGRlZmF1bHQ6IHRydWUpCiAqIEBwYXJhbSBudWxsfGludCAkbWF4TG9nQm9keUxlbmd0aCBNYXhpbXVtIGxlbmd0aCBmb3IgbG9nIGJvZHkrYXR0cmlidXRlcyBjb2x1bW4gKG51bGwgPSBubyBsaW1pdCkKICogQHBhcmFtIENvbnNvbGVMb2dPcHRpb25zICRsb2dPcHRpb25zIERpc3BsYXkgb3B0aW9ucyBmb3IgbG9nIHJlY29yZHMKICogQHBhcmFtIENvbnNvbGVNZXRyaWNPcHRpb25zICRtZXRyaWNPcHRpb25zIERpc3BsYXkgb3B0aW9ucyBmb3IgbWV0cmljcwogKiBAcGFyYW0gQ29uc29sZVNwYW5PcHRpb25zICRzcGFuT3B0aW9ucyBEaXNwbGF5IG9wdGlvbnMgZm9yIHNwYW5zCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":776,"slug":"console-span-options","name":"console_span_options","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleSpanOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlU3Bhbk9wdGlvbnMgd2l0aCBhbGwgZGlzcGxheSBvcHRpb25zIGVuYWJsZWQgKGRlZmF1bHQgYmVoYXZpb3IpLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":785,"slug":"console-span-options-minimal","name":"console_span_options_minimal","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleSpanOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlU3Bhbk9wdGlvbnMgd2l0aCBtaW5pbWFsIGRpc3BsYXkgKGxlZ2FjeSBjb21wYWN0IGZvcm1hdCkuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":794,"slug":"console-log-options","name":"console_log_options","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleLogOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTG9nT3B0aW9ucyB3aXRoIGFsbCBkaXNwbGF5IG9wdGlvbnMgZW5hYmxlZCAoZGVmYXVsdCBiZWhhdmlvcikuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":803,"slug":"console-log-options-minimal","name":"console_log_options_minimal","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleLogOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTG9nT3B0aW9ucyB3aXRoIG1pbmltYWwgZGlzcGxheSAobGVnYWN5IGNvbXBhY3QgZm9ybWF0KS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":812,"slug":"console-metric-options","name":"console_metric_options","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleMetricOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTWV0cmljT3B0aW9ucyB3aXRoIGFsbCBkaXNwbGF5IG9wdGlvbnMgZW5hYmxlZCAoZGVmYXVsdCBiZWhhdmlvcikuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":821,"slug":"console-metric-options-minimal","name":"console_metric_options_minimal","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ConsoleMetricOptions","namespace":"Flow\\Telemetry\\Provider\\Console","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBDb25zb2xlTWV0cmljT3B0aW9ucyB3aXRoIG1pbmltYWwgZGlzcGxheSAobGVnYWN5IGNvbXBhY3QgZm9ybWF0KS4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":830,"slug":"always-on-exemplar-filter","name":"always_on_exemplar_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOnExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPbkV4ZW1wbGFyRmlsdGVyLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":839,"slug":"always-off-exemplar-filter","name":"always_off_exemplar_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOffExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPZmZFeGVtcGxhckZpbHRlci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":848,"slug":"trace-based-exemplar-filter","name":"trace_based_exemplar_filter","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"TraceBasedExemplarFilter","namespace":"Flow\\Telemetry\\Meter\\Exemplar","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlQmFzZWRFeGVtcGxhckZpbHRlci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":857,"slug":"always-on-sampler","name":"always_on_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOnSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPblNhbXBsZXIuIFJlY29yZHMgYW5kIHNhbXBsZXMgZXZlcnkgc3Bhbi4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":866,"slug":"always-off-sampler","name":"always_off_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"AlwaysOffSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBbHdheXNPZmZTYW1wbGVyLiBEcm9wcyBldmVyeSBzcGFuLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":877,"slug":"trace-id-ratio-based-sampler","name":"trace_id_ratio_based_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"ratio","type":[{"name":"float","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"TraceIdRatioBasedSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRyYWNlSWRSYXRpb0Jhc2VkU2FtcGxlci4gU2FtcGxlcyBhIGRldGVybWluaXN0aWMgZnJhY3Rpb24gb2YgdHJhY2VzLgogKgogKiBAcGFyYW0gZmxvYXQgJHJhdGlvIFNhbXBsaW5nIHByb2JhYmlsaXR5IGJldHdlZW4gMC4wIGFuZCAxLjAKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":889,"slug":"parent-based-sampler","name":"parent_based_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"root","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\AlwaysOnSampler::..."}],"return_type":[{"name":"ParentBasedSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFBhcmVudEJhc2VkU2FtcGxlci4gSG9ub3JzIHRoZSBwYXJlbnQgc3BhbidzIHNhbXBsaW5nIGRlY2lzaW9uLCBmYWxsaW5nCiAqIGJhY2sgdG8gdGhlIHJvb3Qgc2FtcGxlciBmb3Igc3BhbnMgd2l0aG91dCBhIHBhcmVudC4KICoKICogQHBhcmFtIFNhbXBsZXIgJHJvb3QgU2FtcGxlciB1c2VkIGZvciByb290IHNwYW5zIChubyBwYXJlbnQpCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":905,"slug":"attribute-matching-sampler","name":"attribute_matching_sampler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"filter","type":[{"name":"AttributeFilter","namespace":"Flow\\Telemetry\\Filter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"delegate","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\AlwaysOnSampler::..."}],"return_type":[{"name":"AttributeMatchingSampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBdHRyaWJ1dGVNYXRjaGluZ1NhbXBsZXIuIERyb3BzIHNwYW5zIHdob3NlIHN0YXJ0LXRpbWUgYXR0cmlidXRlcyBtYXRjaAogKiB0aGUgZmlsdGVyIChvciBrZWVwcyBPTkxZIG1hdGNoaW5nIHNwYW5zIHdoZW4gdGhlIGZpbHRlcidzIGV4Y2x1ZGUgaXMgZmFsc2UpLCBhbmQKICogZGVmZXJzIGFsbCBvdGhlciBzcGFucyB0byB0aGUgZGVsZWdhdGUgc2FtcGxlci4KICoKICogT25seSBhdHRyaWJ1dGVzIGF2YWlsYWJsZSBhdCBzcGFuIHN0YXJ0IGFyZSB2aXNpYmxlOyBhdHRyaWJ1dGVzIGFkZGVkIGxhdGVyIGFyZSBub3QuCiAqCiAqIEBwYXJhbSBBdHRyaWJ1dGVGaWx0ZXIgJGZpbHRlciBUaGUgYXR0cmlidXRlIGZpbHRlciBldmFsdWF0ZWQgYWdhaW5zdCB0aGUgc3BhbidzIHN0YXJ0IGF0dHJpYnV0ZXMKICogQHBhcmFtIFNhbXBsZXIgJGRlbGVnYXRlIFNhbXBsZXIgdGhhdCBkZWNpZGVzIHNwYW5zIHdoaWNoIGRvIG5vdCBtYXRjaCAoZGVmYXVsdDogQWx3YXlzT25TYW1wbGVyKQogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":919,"slug":"propagation-context","name":"propagation_context","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"spanContext","type":[{"name":"SpanContext","namespace":"Flow\\Telemetry\\Tracer","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"baggage","type":[{"name":"Baggage","namespace":"Flow\\Telemetry\\Context","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"PropagationContext","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"TYPE"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFByb3BhZ2F0aW9uQ29udGV4dC4KICoKICogQHBhcmFtIG51bGx8U3BhbkNvbnRleHQgJHNwYW5Db250ZXh0IE9wdGlvbmFsIHNwYW4gY29udGV4dAogKiBAcGFyYW0gbnVsbHxCYWdnYWdlICRiYWdnYWdlIE9wdGlvbmFsIGJhZ2dhZ2UKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":930,"slug":"array-carrier","name":"array_carrier","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"data","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ArrayCarrier","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBBcnJheUNhcnJpZXIuCiAqCiAqIEBwYXJhbSBhcnJheTxzdHJpbmcsIHN0cmluZz4gJGRhdGEgSW5pdGlhbCBjYXJyaWVyIGRhdGEKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":939,"slug":"superglobal-carrier","name":"superglobal_carrier","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"SuperglobalCarrier","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFN1cGVyZ2xvYmFsQ2Fycmllci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":948,"slug":"w3c-trace-context","name":"w3c_trace_context","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"W3CTraceContext","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFczQ1RyYWNlQ29udGV4dCBwcm9wYWdhdG9yLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":957,"slug":"w3c-baggage","name":"w3c_baggage","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"W3CBaggage","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFczQ0JhZ2dhZ2UgcHJvcGFnYXRvci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":968,"slug":"composite-propagator","name":"composite_propagator","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"propagators","type":[{"name":"Propagator","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"CompositePropagator","namespace":"Flow\\Telemetry\\Propagation","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENvbXBvc2l0ZVByb3BhZ2F0b3IuCiAqCiAqIEBwYXJhbSBQcm9wYWdhdG9yIC4uLiRwcm9wYWdhdG9ycyBUaGUgcHJvcGFnYXRvcnMgdG8gY29tYmluZQogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":979,"slug":"chain-detector","name":"chain_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"detectors","type":[{"name":"ResourceDetector","namespace":"Flow\\Telemetry\\Resource","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"ChainDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENoYWluRGV0ZWN0b3IuCiAqCiAqIEBwYXJhbSBSZXNvdXJjZURldGVjdG9yIC4uLiRkZXRlY3RvcnMgVGhlIGRldGVjdG9ycyB0byBjaGFpbgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":988,"slug":"os-detector","name":"os_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"OsDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPc0RldGVjdG9yLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":997,"slug":"host-detector","name":"host_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"HostDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEhvc3REZXRlY3Rvci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1006,"slug":"process-detector","name":"process_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ProcessDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFByb2Nlc3NEZXRlY3Rvci4KICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1015,"slug":"environment-detector","name":"environment_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"EnvironmentDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBFbnZpcm9ubWVudERldGVjdG9yLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1024,"slug":"composer-detector","name":"composer_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ComposerDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENvbXBvc2VyRGV0ZWN0b3IuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1036,"slug":"git-detector","name":"git_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"workingDirectory","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"gitBinary","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'git'"}],"return_type":[{"name":"GitDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEdpdERldGVjdG9yLgogKgogKiBAcGFyYW0gbnVsbHxzdHJpbmcgJHdvcmtpbmdEaXJlY3RvcnkgRGlyZWN0b3J5IHRvIHJ1biBnaXQgaW4gKGRlZmF1bHQ6IGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkpCiAqIEBwYXJhbSBzdHJpbmcgJGdpdEJpbmFyeSBQYXRoIHRvIHRoZSBnaXQgYmluYXJ5IChkZWZhdWx0OiAiZ2l0IiwgcmVzb2x2ZWQgZnJvbSAkUEFUSCkKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1047,"slug":"manual-detector","name":"manual_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"attributes","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ManualDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIE1hbnVhbERldGVjdG9yLgogKgogKiBAcGFyYW0gYXJyYXk8c3RyaW5nLCBhcnJheTxhcnJheS1rZXksIG1peGVkPnxib29sfFxEYXRlVGltZUludGVyZmFjZXxmbG9hdHxpbnR8c3RyaW5nfFxUaHJvd2FibGU+ICRhdHRyaWJ1dGVzIFJlc291cmNlIGF0dHJpYnV0ZXMKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1059,"slug":"caching-detector","name":"caching_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"detector","type":[{"name":"ResourceDetector","namespace":"Flow\\Telemetry\\Resource","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"cachePath","type":[{"name":"string","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"CachingDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIENhY2hpbmdEZXRlY3Rvci4KICoKICogQHBhcmFtIFJlc291cmNlRGV0ZWN0b3IgJGRldGVjdG9yIFRoZSBkZXRlY3RvciB0byB3cmFwCiAqIEBwYXJhbSBudWxsfHN0cmluZyAkY2FjaGVQYXRoIENhY2hlIGZpbGUgcGF0aCAoZGVmYXVsdDogc3lzX2dldF90ZW1wX2RpcigpL2Zsb3dfdGVsZW1ldHJ5X3Jlc291cmNlLmNhY2hlKQogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1070,"slug":"resource-detector","name":"resource_detector","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"detectors","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"}],"return_type":[{"name":"ChainDetector","namespace":"Flow\\Telemetry\\Resource\\Detector","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHJlc291cmNlIGRldGVjdG9yIGNoYWluLgogKgogKiBAcGFyYW0gYXJyYXk8UmVzb3VyY2VEZXRlY3Rvcj4gJGRldGVjdG9ycyBPcHRpb25hbCBjdXN0b20gZGV0ZWN0b3JzIChlbXB0eSA9IHVzZSBkZWZhdWx0cykKICov"},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1089,"slug":"error-log-handler","name":"error_log_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"messageType","type":[{"name":"ErrorLogMessageType","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogMessageType::..."},{"name":"expandNewlines","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"},{"name":"messagePrefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'[flow-telemetry]'"}],"return_type":[{"name":"ErrorLogHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSB0aGUgZGVmYXVsdCBFcnJvckxvZ0hhbmRsZXIuIFdyaXRlcyB2aWEgUEhQJ3MgZXJyb3JfbG9nKCkuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1102,"slug":"stream-error-handler","name":"stream_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"destination","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filePermissions","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"420"},{"name":"createDirectories","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"messagePrefix","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'[flow-telemetry]'"}],"return_type":[{"name":"StreamHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFN0cmVhbUhhbmRsZXIuIEFwcGVuZHMgZm9ybWF0dGVkIFRocm93YWJsZXMgKG9uZSBwZXIgbGluZSkgdG8gYSBmaWxlCiAqIHBhdGggb3IgcGhwOi8vIHN0cmVhbSB3cmFwcGVyLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1115,"slug":"syslog-error-handler","name":"syslog_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"ident","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'flow-telemetry'"},{"name":"facility","type":[{"name":"SyslogFacility","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogFacility::..."},{"name":"logOpts","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"1"},{"name":"severity","type":[{"name":"SyslogSeverity","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogSeverity::..."}],"return_type":[{"name":"SyslogHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFN5c2xvZ0hhbmRsZXIuIFdyaXRlcyB2aWEgb3BlbmxvZy9zeXNsb2cvY2xvc2Vsb2cuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1128,"slug":"udp-syslog-error-handler","name":"udp_syslog_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"port","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"514"},{"name":"ident","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'flow-telemetry'"},{"name":"facility","type":[{"name":"SyslogFacility","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogFacility::..."},{"name":"severity","type":[{"name":"SyslogSeverity","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\SyslogSeverity::..."}],"return_type":[{"name":"UdpSyslogHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFVkcFN5c2xvZ0hhbmRsZXIuIFNlbmRzIFJGQyA1NDI0LXN0eWxlIHN5c2xvZyBmcmFtZXMgb3ZlciBVRFAuCiAqLw=="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1142,"slug":"composite-error-handler","name":"composite_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[{"name":"handlers","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":true,"default_value":null}],"return_type":[{"name":"CompositeErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEZhbiBlcnJvcnMgb3V0IHRvIG11bHRpcGxlIGhhbmRsZXJzLgogKi8="},{"repository_path":"src\/lib\/telemetry\/src\/Flow\/Telemetry\/DSL\/functions.php","start_line_in_file":1151,"slug":"null-error-handler","name":"null_error_handler","namespace":"Flow\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"NullErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIERpc2NhcmQgZXZlcnkgZXJyb3IuIFVzZSBvbmx5IGluIHRlc3RzIG9yIGZvciBleHBsaWNpdCBzaWxlbmNlLgogKi8="},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":29,"slug":"azurite-url-factory","name":"azurite_url_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'localhost'"},{"name":"port","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'10000'"},{"name":"secure","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"false"}],"return_type":[{"name":"AzuriteURLFactory","namespace":"Flow\\Azure\\SDK\\BlobService\\URLFactory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":38,"slug":"azure-shared-key-authorization-factory","name":"azure_shared_key_authorization_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"account","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"key","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"SharedKeyFactory","namespace":"Flow\\Azure\\SDK\\AuthorizationFactory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":48,"slug":"azure-blob-service-config","name":"azure_blob_service_config","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"account","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"container","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"Configuration","namespace":"Flow\\Azure\\SDK\\BlobService","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":54,"slug":"azure-url-factory","name":"azure_url_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'blob.core.windows.net'"}],"return_type":[{"name":"AzureURLFactory","namespace":"Flow\\Azure\\SDK\\BlobService\\URLFactory","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":60,"slug":"azure-http-factory","name":"azure_http_factory","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"request_factory","type":[{"name":"RequestFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"stream_factory","type":[{"name":"StreamFactoryInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"HttpFactory","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/lib\/azure-sdk\/src\/Flow\/Azure\/SDK\/DSL\/functions.php","start_line_in_file":68,"slug":"azure-blob-service","name":"azure_blob_service","namespace":"Flow\\Azure\\SDK\\DSL","parameters":[{"name":"configuration","type":[{"name":"Configuration","namespace":"Flow\\Azure\\SDK\\BlobService","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"azure_authorization_factory","type":[{"name":"AuthorizationFactory","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"azure_http_factory","type":[{"name":"HttpFactory","namespace":"Flow\\Azure\\SDK","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"azure_url_factory","type":[{"name":"URLFactory","namespace":"Flow\\Azure\\SDK","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"logger","type":[{"name":"LoggerInterface","namespace":"Psr\\Log","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"BlobServiceInterface","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_SDK","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/azure\/src\/Flow\/Filesystem\/Bridge\/Azure\/DSL\/functions.php","start_line_in_file":16,"slug":"azure-filesystem-options","name":"azure_filesystem_options","namespace":"Flow\\Filesystem\\Bridge\\Azure\\DSL","parameters":[],"return_type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\Azure","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/azure\/src\/Flow\/Filesystem\/Bridge\/Azure\/DSL\/functions.php","start_line_in_file":22,"slug":"azure-filesystem","name":"azure_filesystem","namespace":"Flow\\Filesystem\\Bridge\\Azure\\DSL","parameters":[{"name":"blob_service","type":[{"name":"BlobServiceInterface","namespace":"Flow\\Azure\\SDK","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\Azure","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Bridge\\Azure\\Options::..."},{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'azure-blob'"}],"return_type":[{"name":"AzureBlobFilesystem","namespace":"Flow\\Filesystem\\Bridge\\Azure","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"AZURE_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/async-aws\/src\/Flow\/Filesystem\/Bridge\/AsyncAWS\/DSL\/functions.php","start_line_in_file":20,"slug":"aws-s3-client","name":"aws_s3_client","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS\\DSL","parameters":[{"name":"configuration","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"S3Client","namespace":"AsyncAws\\S3","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"S3_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEBwYXJhbSBhcnJheTxDb25maWd1cmF0aW9uOjpPUFRJT05fKiwgbnVsbHxzdHJpbmc+ICRjb25maWd1cmF0aW9uIC0gZm9yIGRldGFpbHMgcGxlYXNlIHNlZSBodHRwczovL2FzeW5jLWF3cy5jb20vY2xpZW50cy9zMy5odG1sCiAqLw=="},{"repository_path":"src\/bridge\/filesystem\/async-aws\/src\/Flow\/Filesystem\/Bridge\/AsyncAWS\/DSL\/functions.php","start_line_in_file":26,"slug":"aws-s3-filesystem","name":"aws_s3_filesystem","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS\\DSL","parameters":[{"name":"bucket","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"s3Client","type":[{"name":"S3Client","namespace":"AsyncAws\\S3","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Bridge\\AsyncAWS\\Options::..."},{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'aws-s3'"}],"return_type":[{"name":"AsyncAWSS3Filesystem","namespace":"Flow\\Filesystem\\Bridge\\AsyncAWS","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"S3_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/sftp\/src\/Flow\/Filesystem\/Bridge\/SFTP\/DSL\/functions.php","start_line_in_file":24,"slug":"sftp-client","name":"sftp_client","namespace":"Flow\\Filesystem\\Bridge\\SFTP\\DSL","parameters":[{"name":"host","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"user","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"credential","type":[{"name":"PrivateKey","namespace":"phpseclib4\\Crypt\\Common","is_nullable":false,"is_variadic":false},{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"port","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"22"}],"return_type":[{"name":"SFTP","namespace":"phpseclib4\\Net","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SFTP_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIEB0aHJvd3MgUnVudGltZUV4Y2VwdGlvbgogKi8="},{"repository_path":"src\/bridge\/filesystem\/sftp\/src\/Flow\/Filesystem\/Bridge\/SFTP\/DSL\/functions.php","start_line_in_file":46,"slug":"sftp-filesystem","name":"sftp_filesystem","namespace":"Flow\\Filesystem\\Bridge\\SFTP\\DSL","parameters":[{"name":"sftp","type":[{"name":"SFTP","namespace":"phpseclib4\\Net","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"options","type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\SFTP","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Filesystem\\Bridge\\SFTP\\Options::..."},{"name":"protocol","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"'sftp'"}],"return_type":[{"name":"SFTPFilesystem","namespace":"Flow\\Filesystem\\Bridge\\SFTP","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SFTP_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/filesystem\/sftp\/src\/Flow\/Filesystem\/Bridge\/SFTP\/DSL\/functions.php","start_line_in_file":52,"slug":"sftp-filesystem-options","name":"sftp_filesystem_options","namespace":"Flow\\Filesystem\\Bridge\\SFTP\\DSL","parameters":[],"return_type":[{"name":"Options","namespace":"Flow\\Filesystem\\Bridge\\SFTP","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SFTP_FILESYSTEM","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":40,"slug":"value-normalizer","name":"value_normalizer","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[],"return_type":[{"name":"ValueNormalizer","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFZhbHVlTm9ybWFsaXplciBmb3IgY29udmVydGluZyBhcmJpdHJhcnkgUEhQIHZhbHVlcyB0byBUZWxlbWV0cnkgYXR0cmlidXRlIHR5cGVzLgogKgogKiBUaGUgbm9ybWFsaXplciBoYW5kbGVzOgogKiAtIG51bGwg4oaSICdudWxsJyBzdHJpbmcKICogLSBzY2FsYXJzIChzdHJpbmcsIGludCwgZmxvYXQsIGJvb2wpIOKGkiB1bmNoYW5nZWQKICogLSBEYXRlVGltZUludGVyZmFjZSDihpIgdW5jaGFuZ2VkCiAqIC0gVGhyb3dhYmxlIOKGkiB1bmNoYW5nZWQKICogLSBhcnJheXMg4oaSIHJlY3Vyc2l2ZWx5IG5vcm1hbGl6ZWQKICogLSBvYmplY3RzIHdpdGggX190b1N0cmluZygpIOKGkiBzdHJpbmcgY2FzdAogKiAtIG9iamVjdHMgd2l0aG91dCBfX3RvU3RyaW5nKCkg4oaSIGNsYXNzIG5hbWUKICogLSBvdGhlciB0eXBlcyDihpIgZ2V0X2RlYnVnX3R5cGUoKSByZXN1bHQKICoKICogRXhhbXBsZSB1c2FnZToKICogYGBgcGhwCiAqICRub3JtYWxpemVyID0gdmFsdWVfbm9ybWFsaXplcigpOwogKiAkbm9ybWFsaXplZCA9ICRub3JtYWxpemVyLT5ub3JtYWxpemUoJHZhbHVlKTsKICogYGBgCiAqLw=="},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":73,"slug":"severity-mapper","name":"severity_mapper","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[{"name":"customMapping","type":[{"name":"array","namespace":null,"is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"SeverityMapper","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFNldmVyaXR5TWFwcGVyIGZvciBtYXBwaW5nIE1vbm9sb2cgbGV2ZWxzIHRvIFRlbGVtZXRyeSBzZXZlcml0aWVzLgogKgogKiBAcGFyYW0gbnVsbHxhcnJheTxpbnQsIFNldmVyaXR5PiAkY3VzdG9tTWFwcGluZyBPcHRpb25hbCBjdXN0b20gbWFwcGluZyAoTW9ub2xvZyBMZXZlbCB2YWx1ZSA9PiBUZWxlbWV0cnkgU2V2ZXJpdHkpCiAqCiAqIEV4YW1wbGUgd2l0aCBkZWZhdWx0IG1hcHBpbmc6CiAqIGBgYHBocAogKiAkbWFwcGVyID0gc2V2ZXJpdHlfbWFwcGVyKCk7CiAqIGBgYAogKgogKiBFeGFtcGxlIHdpdGggY3VzdG9tIG1hcHBpbmc6CiAqIGBgYHBocAogKiB1c2UgTW9ub2xvZ1xMZXZlbDsKICogdXNlIEZsb3dcVGVsZW1ldHJ5XExvZ2dlclxTZXZlcml0eTsKICoKICogJG1hcHBlciA9IHNldmVyaXR5X21hcHBlcihbCiAqICAgICBMZXZlbDo6RGVidWctPnZhbHVlID0+IFNldmVyaXR5OjpERUJVRywKICogICAgIExldmVsOjpJbmZvLT52YWx1ZSA9PiBTZXZlcml0eTo6SU5GTywKICogICAgIExldmVsOjpOb3RpY2UtPnZhbHVlID0+IFNldmVyaXR5OjpXQVJOLCAgLy8gQ3VzdG9tOiBOT1RJQ0Ug4oaSIFdBUk4gaW5zdGVhZCBvZiBJTkZPCiAqICAgICBMZXZlbDo6V2FybmluZy0+dmFsdWUgPT4gU2V2ZXJpdHk6OldBUk4sCiAqICAgICBMZXZlbDo6RXJyb3ItPnZhbHVlID0+IFNldmVyaXR5OjpFUlJPUiwKICogICAgIExldmVsOjpDcml0aWNhbC0+dmFsdWUgPT4gU2V2ZXJpdHk6OkZBVEFMLAogKiAgICAgTGV2ZWw6OkFsZXJ0LT52YWx1ZSA9PiBTZXZlcml0eTo6RkFUQUwsCiAqICAgICBMZXZlbDo6RW1lcmdlbmN5LT52YWx1ZSA9PiBTZXZlcml0eTo6RkFUQUwsCiAqIF0pOwogKiBgYGAKICov"},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":107,"slug":"log-record-converter","name":"log_record_converter","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[{"name":"severityMapper","type":[{"name":"SeverityMapper","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"valueNormalizer","type":[{"name":"ValueNormalizer","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"LogRecordConverter","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIExvZ1JlY29yZENvbnZlcnRlciBmb3IgY29udmVydGluZyBNb25vbG9nIExvZ1JlY29yZCB0byBUZWxlbWV0cnkgTG9nUmVjb3JkLgogKgogKiBUaGUgY29udmVydGVyIGhhbmRsZXM6CiAqIC0gU2V2ZXJpdHkgbWFwcGluZyBmcm9tIE1vbm9sb2cgTGV2ZWwgdG8gVGVsZW1ldHJ5IFNldmVyaXR5CiAqIC0gTWVzc2FnZSBib2R5IGNvbnZlcnNpb24KICogLSBDaGFubmVsIGFuZCBsZXZlbCBuYW1lIGFzIG1vbm9sb2cuKiBhdHRyaWJ1dGVzCiAqIC0gQ29udGV4dCB2YWx1ZXMgYXMgY29udGV4dC4qIGF0dHJpYnV0ZXMgKFRocm93YWJsZXMgdXNlIHNldEV4Y2VwdGlvbigpKQogKiAtIEV4dHJhIHZhbHVlcyBhcyBleHRyYS4qIGF0dHJpYnV0ZXMKICoKICogQHBhcmFtIG51bGx8U2V2ZXJpdHlNYXBwZXIgJHNldmVyaXR5TWFwcGVyIEN1c3RvbSBzZXZlcml0eSBtYXBwZXIgKGRlZmF1bHRzIHRvIHN0YW5kYXJkIG1hcHBpbmcpCiAqIEBwYXJhbSBudWxsfFZhbHVlTm9ybWFsaXplciAkdmFsdWVOb3JtYWxpemVyIEN1c3RvbSB2YWx1ZSBub3JtYWxpemVyIChkZWZhdWx0cyB0byBzdGFuZGFyZCBub3JtYWxpemVyKQogKgogKiBFeGFtcGxlIHVzYWdlOgogKiBgYGBwaHAKICogJGNvbnZlcnRlciA9IGxvZ19yZWNvcmRfY29udmVydGVyKCk7CiAqICR0ZWxlbWV0cnlSZWNvcmQgPSAkY29udmVydGVyLT5jb252ZXJ0KCRtb25vbG9nUmVjb3JkKTsKICogYGBgCiAqCiAqIEV4YW1wbGUgd2l0aCBjdXN0b20gbWFwcGVyOgogKiBgYGBwaHAKICogJGNvbnZlcnRlciA9IGxvZ19yZWNvcmRfY29udmVydGVyKAogKiAgICAgc2V2ZXJpdHlNYXBwZXI6IHNldmVyaXR5X21hcHBlcihbCiAqICAgICAgICAgTGV2ZWw6OkRlYnVnLT52YWx1ZSA9PiBTZXZlcml0eTo6VFJBQ0UsCiAqICAgICBdKQogKiApOwogKiBgYGAKICov"},{"repository_path":"src\/bridge\/monolog\/telemetry\/src\/Flow\/Bridge\/Monolog\/Telemetry\/DSL\/functions.php","start_line_in_file":149,"slug":"telemetry-handler","name":"telemetry_handler","namespace":"Flow\\Bridge\\Monolog\\Telemetry\\DSL","parameters":[{"name":"logger","type":[{"name":"Logger","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"converter","type":[{"name":"LogRecordConverter","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Monolog\\Telemetry\\LogRecordConverter::..."},{"name":"level","type":[{"name":"Level","namespace":"Monolog","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Monolog\\Level::..."},{"name":"bubble","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"TelemetryHandler","namespace":"Flow\\Bridge\\Monolog\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"MONOLOG_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFRlbGVtZXRyeUhhbmRsZXIgZm9yIGZvcndhcmRpbmcgTW9ub2xvZyBsb2dzIHRvIEZsb3cgVGVsZW1ldHJ5LgogKgogKiBAcGFyYW0gTG9nZ2VyICRsb2dnZXIgVGhlIEZsb3cgVGVsZW1ldHJ5IGxvZ2dlciB0byBmb3J3YXJkIGxvZ3MgdG8KICogQHBhcmFtIExvZ1JlY29yZENvbnZlcnRlciAkY29udmVydGVyIENvbnZlcnRlciB0byB0cmFuc2Zvcm0gTW9ub2xvZyBMb2dSZWNvcmQgdG8gVGVsZW1ldHJ5IExvZ1JlY29yZAogKiBAcGFyYW0gTGV2ZWwgJGxldmVsIFRoZSBtaW5pbXVtIGxvZ2dpbmcgbGV2ZWwgYXQgd2hpY2ggdGhpcyBoYW5kbGVyIHdpbGwgYmUgdHJpZ2dlcmVkCiAqIEBwYXJhbSBib29sICRidWJibGUgV2hldGhlciBtZXNzYWdlcyBoYW5kbGVkIGJ5IHRoaXMgaGFuZGxlciBzaG91bGQgYnViYmxlIHVwIHRvIG90aGVyIGhhbmRsZXJzCiAqCiAqIEV4YW1wbGUgdXNhZ2U6CiAqIGBgYHBocAogKiB1c2UgTW9ub2xvZ1xMb2dnZXIgYXMgTW9ub2xvZ0xvZ2dlcjsKICogdXNlIGZ1bmN0aW9uIEZsb3dcQnJpZGdlXE1vbm9sb2dcVGVsZW1ldHJ5XERTTFx0ZWxlbWV0cnlfaGFuZGxlcjsKICogdXNlIGZ1bmN0aW9uIEZsb3dcVGVsZW1ldHJ5XERTTFx0ZWxlbWV0cnk7CiAqCiAqICR0ZWxlbWV0cnkgPSB0ZWxlbWV0cnkoKTsKICogJGxvZ2dlciA9ICR0ZWxlbWV0cnktPmxvZ2dlcignbXktYXBwJyk7CiAqCiAqICRtb25vbG9nID0gbmV3IE1vbm9sb2dMb2dnZXIoJ2NoYW5uZWwnKTsKICogJG1vbm9sb2ctPnB1c2hIYW5kbGVyKHRlbGVtZXRyeV9oYW5kbGVyKCRsb2dnZXIpKTsKICoKICogJG1vbm9sb2ctPmluZm8oJ1VzZXIgbG9nZ2VkIGluJywgWyd1c2VyX2lkJyA9PiAxMjNdKTsKICogLy8g4oaSIEZvcndhcmRlZCB0byBGbG93IFRlbGVtZXRyeSB3aXRoIElORk8gc2V2ZXJpdHkKICogYGBgCiAqCiAqIEV4YW1wbGUgd2l0aCBjdXN0b20gY29udmVydGVyOgogKiBgYGBwaHAKICogJGNvbnZlcnRlciA9IGxvZ19yZWNvcmRfY29udmVydGVyKAogKiAgICAgc2V2ZXJpdHlNYXBwZXI6IHNldmVyaXR5X21hcHBlcihbCiAqICAgICAgICAgTGV2ZWw6OkRlYnVnLT52YWx1ZSA9PiBTZXZlcml0eTo6VFJBQ0UsCiAqICAgICBdKQogKiApOwogKiAkbW9ub2xvZy0+cHVzaEhhbmRsZXIodGVsZW1ldHJ5X2hhbmRsZXIoJGxvZ2dlciwgJGNvbnZlcnRlcikpOwogKiBgYGAKICov"},{"repository_path":"src\/bridge\/symfony\/http-foundation-telemetry\/src\/Flow\/Bridge\/Symfony\/HttpFoundationTelemetry\/DSL\/functions.php","start_line_in_file":16,"slug":"symfony-request-carrier","name":"symfony_request_carrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry\\DSL","parameters":[{"name":"request","type":[{"name":"Request","namespace":"Symfony\\Component\\HttpFoundation","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestCarrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SYMFONY_HTTP_FOUNDATION_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/symfony\/http-foundation-telemetry\/src\/Flow\/Bridge\/Symfony\/HttpFoundationTelemetry\/DSL\/functions.php","start_line_in_file":22,"slug":"symfony-response-carrier","name":"symfony_response_carrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry\\DSL","parameters":[{"name":"response","type":[{"name":"Response","namespace":"Symfony\\Component\\HttpFoundation","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ResponseCarrier","namespace":"Flow\\Bridge\\Symfony\\HttpFoundationTelemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"SYMFONY_HTTP_FOUNDATION_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/psr7\/telemetry\/src\/Flow\/Bridge\/Psr7\/Telemetry\/DSL\/functions.php","start_line_in_file":16,"slug":"psr7-request-carrier","name":"psr7_request_carrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry\\DSL","parameters":[{"name":"request","type":[{"name":"ServerRequestInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"RequestCarrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PSR7_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/psr7\/telemetry\/src\/Flow\/Bridge\/Psr7\/Telemetry\/DSL\/functions.php","start_line_in_file":22,"slug":"psr7-response-carrier","name":"psr7_response_carrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry\\DSL","parameters":[{"name":"response","type":[{"name":"ResponseInterface","namespace":"Psr\\Http\\Message","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"ResponseCarrier","namespace":"Flow\\Bridge\\Psr7\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PSR7_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/psr18\/telemetry\/src\/Flow\/Bridge\/Psr18\/Telemetry\/DSL\/functions.php","start_line_in_file":15,"slug":"psr18-traceable-client","name":"psr18_traceable_client","namespace":"Flow\\Bridge\\Psr18\\Telemetry\\DSL","parameters":[{"name":"client","type":[{"name":"ClientInterface","namespace":"Psr\\Http\\Client","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"telemetry","type":[{"name":"Telemetry","namespace":"Flow\\Telemetry","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null}],"return_type":[{"name":"PSR18TraceableClient","namespace":"Flow\\Bridge\\Psr18\\Telemetry","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"PSR18_TELEMETRY_BRIDGE","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":null},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":49,"slug":"otlp-json-serializer","name":"otlp_json_serializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"JsonSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIEpTT04gc2VyaWFsaXplciBmb3IgT1RMUC4KICoKICogUmV0dXJucyBhIEpzb25TZXJpYWxpemVyIHRoYXQgY29udmVydHMgdGVsZW1ldHJ5IGRhdGEgdG8gT1RMUCBKU09OIHdpcmUgZm9ybWF0LgogKiBVc2UgdGhpcyB3aXRoIEN1cmxUcmFuc3BvcnQgZm9yIEpTT04gb3ZlciBIVFRQLgogKgogKiBFeGFtcGxlIHVzYWdlOgogKiBgYGBwaHAKICogJHNlcmlhbGl6ZXIgPSBvdGxwX2pzb25fc2VyaWFsaXplcigpOwogKiAkdHJhbnNwb3J0ID0gb3RscF9jdXJsX3RyYW5zcG9ydCgkZW5kcG9pbnQsICRzZXJpYWxpemVyKTsKICogYGBgCiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":70,"slug":"otlp-protobuf-serializer","name":"otlp_protobuf_serializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"ProtobufSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIFByb3RvYnVmIHNlcmlhbGl6ZXIgZm9yIE9UTFAuCiAqCiAqIFJldHVybnMgYSBQcm90b2J1ZlNlcmlhbGl6ZXIgdGhhdCBjb252ZXJ0cyB0ZWxlbWV0cnkgZGF0YSB0byBPVExQIFByb3RvYnVmIGJpbmFyeSBmb3JtYXQuCiAqIFVzZSB0aGlzIHdpdGggQ3VybFRyYW5zcG9ydCBmb3IgUHJvdG9idWYgb3ZlciBIVFRQLCBvciB3aXRoIEdycGNUcmFuc3BvcnQuCiAqCiAqIFJlcXVpcmVzOgogKiAtIGdvb2dsZS9wcm90b2J1ZiBwYWNrYWdlCiAqCiAqIEV4YW1wbGUgdXNhZ2U6CiAqIGBgYHBocAogKiAkc2VyaWFsaXplciA9IG90bHBfcHJvdG9idWZfc2VyaWFsaXplcigpOwogKiAkdHJhbnNwb3J0ID0gb3RscF9jdXJsX3RyYW5zcG9ydCgkZW5kcG9pbnQsICRzZXJpYWxpemVyKTsKICogYGBgCiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":94,"slug":"otlp-grpc-transport","name":"otlp_grpc_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"endpoint","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"headers","type":[{"name":"array","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"[]"},{"name":"insecure","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"},{"name":"timeoutMs","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"250"},{"name":"shutdownTimeoutMs","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"5000"},{"name":"failover","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGdSUEMgdHJhbnNwb3J0IGZvciBPVExQIGVuZHBvaW50cy4KICoKICogQ3JlYXRlcyBhIEdycGNUcmFuc3BvcnQgY29uZmlndXJlZCB0byBzZW5kIHRlbGVtZXRyeSBkYXRhIHRvIGFuIE9UTFAtY29tcGF0aWJsZQogKiBlbmRwb2ludCB1c2luZyBnUlBDIHByb3RvY29sIHdpdGggUHJvdG9idWYgc2VyaWFsaXphdGlvbi4gT1RMUC9nUlBDIG1hbmRhdGVzCiAqIFByb3RvYnVmLCBzbyB0aGUgc2VyaWFsaXplciBpcyBidWlsdCBpbnRlcm5hbGx5IGFuZCBub3QgY29uZmlndXJhYmxlLgogKgogKiBSZXF1aXJlczoKICogLSBleHQtZ3JwYyBQSFAgZXh0ZW5zaW9uCiAqIC0gZ29vZ2xlL3Byb3RvYnVmIHBhY2thZ2UKICoKICogQHBhcmFtIHN0cmluZyAkZW5kcG9pbnQgZ1JQQyBlbmRwb2ludCAoZS5nLiwgJ2xvY2FsaG9zdDo0MzE3JykKICogQHBhcmFtIGFycmF5PHN0cmluZywgc3RyaW5nPiAkaGVhZGVycyBBZGRpdGlvbmFsIGhlYWRlcnMgKG1ldGFkYXRhKSB0byBpbmNsdWRlIGluIHJlcXVlc3RzCiAqIEBwYXJhbSBib29sICRpbnNlY3VyZSBXaGV0aGVyIHRvIHVzZSBpbnNlY3VyZSBjaGFubmVsIGNyZWRlbnRpYWxzIChkZWZhdWx0IHRydWUgZm9yIGxvY2FsIGRldikKICogQHBhcmFtIGludCAkdGltZW91dE1zIFBlci1jYWxsIGRlYWRsaW5lIGluIG1pbGxpc2Vjb25kcyAoY292ZXJzIGNvbm5lY3QgKyBzZW5kICsgcmVjZWl2ZSkKICogQHBhcmFtIGludCAkc2h1dGRvd25UaW1lb3V0TXMgV2FsbC1jbG9jayBidWRnZXQgZm9yIGRyYWluaW5nIHBlbmRpbmcgY2FsbHMgYXQgc2h1dGRvd24KICogQHBhcmFtID9UcmFuc3BvcnQgJGZhaWxvdmVyIE9wdGlvbmFsIGZhaWxvdmVyIHRyYW5zcG9ydCByZWNlaXZpbmcgcHJpb3IgYmF0Y2hlcyB3aGVuIHByaW1hcnkgZmFpbHMKICov"},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":109,"slug":"otlp-curl-options","name":"otlp_curl_options","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"CurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBjdXJsIHRyYW5zcG9ydCBvcHRpb25zIGZvciBPVExQLgogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":130,"slug":"otlp-curl-transport","name":"otlp_curl_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"endpoint","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"serializer","type":[{"name":"JsonSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false},{"name":"ProtobufSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer\\JsonSerializer::..."},{"name":"options","type":[{"name":"CurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Transport\\CurlTransportOptions::..."},{"name":"failover","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"}],"return_type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHN5bmNocm9ub3VzIGN1cmwgdHJhbnNwb3J0IGZvciBPVExQIGVuZHBvaW50cy4KICoKICogQ3JlYXRlcyBhIEN1cmxUcmFuc3BvcnQgdGhhdCBkcml2ZXMgZWFjaCByZXF1ZXN0IHRvIGNvbXBsZXRpb24gYW5kIHJlcG9ydHMgdGhlCiAqIG91dGNvbWUgaW1tZWRpYXRlbHkgKHJldHVybnMgb24gc3VjY2VzcywgdGhyb3dzIG9uIGZhaWx1cmUpLiBPVExQL0hUVFAgYWxsb3dzCiAqIEpTT04gb3IgUHJvdG9idWYgZW5jb2Rpbmc7IGRlZmF1bHRzIHRvIEpTT04uIEtlZXBpbmcgZXhwb3J0IG9mZiB0aGUgYXBwbGljYXRpb24KICogaG90IHBhdGggaXMgdGhlIGpvYiBvZiB0aGUgYmF0Y2hpbmcgcHJvY2Vzc29yIGluIGZyb250IG9mIHRoZSBleHBvcnRlci4KICoKICogUmVxdWlyZXM6IGV4dC1jdXJsIFBIUCBleHRlbnNpb24KICoKICogQHBhcmFtIHN0cmluZyAkZW5kcG9pbnQgT1RMUCBlbmRwb2ludCBVUkwgKGUuZy4sICdodHRwOi8vbG9jYWxob3N0OjQzMTgnKQogKiBAcGFyYW0gSnNvblNlcmlhbGl6ZXJ8UHJvdG9idWZTZXJpYWxpemVyICRzZXJpYWxpemVyIFNlcmlhbGl6ZXIgZm9yIGVuY29kaW5nIHRlbGVtZXRyeSBkYXRhIChKU09OIG9yIFByb3RvYnVmKQogKiBAcGFyYW0gQ3VybFRyYW5zcG9ydE9wdGlvbnMgJG9wdGlvbnMgVHJhbnNwb3J0IGNvbmZpZ3VyYXRpb24gb3B0aW9ucwogKiBAcGFyYW0gP1RyYW5zcG9ydCAkZmFpbG92ZXIgT3B0aW9uYWwgZmFpbG92ZXIgdHJhbnNwb3J0IHJlY2VpdmluZyB0aGUgYmF0Y2ggd2hlbiB0aGUgcHJpbWFyeSBmYWlscwogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":143,"slug":"otlp-async-curl-options","name":"otlp_async_curl_options","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[],"return_type":[{"name":"AsyncCurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhc3luYyBjdXJsIHRyYW5zcG9ydCBvcHRpb25zIGZvciBPVExQLgogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":158,"slug":"otlp-async-curl-transport","name":"otlp_async_curl_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"endpoint","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"serializer","type":[{"name":"JsonSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false},{"name":"ProtobufSerializer","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Serializer\\JsonSerializer::..."},{"name":"options","type":[{"name":"AsyncCurlTransportOptions","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Bridge\\Telemetry\\OTLP\\Transport\\AsyncCurlTransportOptions::..."},{"name":"failover","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":true,"is_variadic":false}],"has_default_value":true,"is_nullable":true,"is_variadic":false,"default_value":"null"},{"name":"error_handler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"AsyncCurlTransport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBhc3luY2hyb25vdXMgY3VybCB0cmFuc3BvcnQgZm9yIE9UTFAgZW5kcG9pbnRzLgogKgogKiBAcGFyYW0gc3RyaW5nICRlbmRwb2ludCBPVExQIGVuZHBvaW50IFVSTCAoZS5nLiwgJ2h0dHA6Ly9sb2NhbGhvc3Q6NDMxOCcpCiAqIEBwYXJhbSBKc29uU2VyaWFsaXplcnxQcm90b2J1ZlNlcmlhbGl6ZXIgJHNlcmlhbGl6ZXIgU2VyaWFsaXplciBmb3IgZW5jb2RpbmcgdGVsZW1ldHJ5IGRhdGEgKEpTT04gb3IgUHJvdG9idWYpCiAqIEBwYXJhbSBBc3luY0N1cmxUcmFuc3BvcnRPcHRpb25zICRvcHRpb25zIFRyYW5zcG9ydCBjb25maWd1cmF0aW9uIG9wdGlvbnMKICogQHBhcmFtID9UcmFuc3BvcnQgJGZhaWxvdmVyIE9wdGlvbmFsIGZhaWxvdmVyIHRyYW5zcG9ydCByZWNlaXZpbmcgcHJpb3IgYmF0Y2hlcyB3aGVuIHByaW1hcnkgZmFpbHMKICogQHBhcmFtIEVycm9ySGFuZGxlciAkZXJyb3JfaGFuZGxlciBIYW5kbGVyIGZvciBmYWlsdXJlcyByZWFwZWQgb24gc2VuZCgpL3RpY2soKS9zaHV0ZG93bigpIChubyBmYWlsb3ZlcikKICov"},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":180,"slug":"otlp-stream-transport","name":"otlp_stream_transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"destination","type":[{"name":"string","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"filePermissions","type":[{"name":"int","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"420"},{"name":"createDirectories","type":[{"name":"bool","namespace":null,"is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"true"}],"return_type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHN0cmVhbSB0cmFuc3BvcnQgZm9yIE9UTFAgdGhhdCB3cml0ZXMgSlNPTkwgdG8gYSBzaW5nbGUgZGVzdGluYXRpb24uCiAqCiAqIEFjY2VwdHMgYW4gYWJzb2x1dGUgZmlsZSBwYXRoIG9yIGEgcGhwOi8vIHN0cmVhbSB3cmFwcGVyIHN1Y2ggYXMKICogJ3BocDovL3N0ZG91dCcsICdwaHA6Ly9zdGRlcnInLCAncGhwOi8vbWVtb3J5Jywgb3IgJ3BocDovL3RlbXAnLiBFYWNoCiAqIGV4cG9ydCgpIGNhbGwgYXBwZW5kcyBvbmUgSlNPTiBMaW5lIHVuZGVyIExPQ0tfRVggc28gY29uY3VycmVudCB3cml0ZXJzCiAqIGludGVybGVhdmUgYXQgbGluZSBib3VuZGFyaWVzLiBUaGUgJGZpbGVQZXJtaXNzaW9ucyBhbmQgJGNyZWF0ZURpcmVjdG9yaWVzCiAqIHBhcmFtZXRlcnMgYXBwbHkgb25seSB3aGVuIHRoZSBkZXN0aW5hdGlvbiBpcyBhIGZpbGUgcGF0aC4KICoKICogUGVyIHRoZSBPVExQIEZpbGUgRXhwb3J0ZXIgc3BlYyBvbmx5IEpTT04gZW5jb2RpbmcgaXMgc3VwcG9ydGVkLgogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":203,"slug":"otlp-exporter","name":"otlp_exporter","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"transport","type":[{"name":"Transport","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Transport","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"errorHandler","type":[{"name":"ErrorHandler","namespace":"Flow\\Telemetry\\ErrorHandler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\ErrorHandler\\ErrorLogHandler::..."}],"return_type":[{"name":"OTLPExporter","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\Exporter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhbiBPVExQIGV4cG9ydGVyIHRoYXQgZGlzcGF0Y2hlcyBsb2dzLCBtZXRyaWNzLCBhbmQgc3BhbnMgdGhyb3VnaCBhIHNpbmdsZSB0cmFuc3BvcnQuCiAqCiAqIEV4YW1wbGUgdXNhZ2U6CiAqIGBgYHBocAogKiAkZXhwb3J0ZXIgPSBvdGxwX2V4cG9ydGVyKCR0cmFuc3BvcnQpOwogKiAkc3BhblByb2Nlc3NvciA9IGJhdGNoaW5nX3NwYW5fcHJvY2Vzc29yKCRleHBvcnRlcik7CiAqICRtZXRyaWNQcm9jZXNzb3IgPSBiYXRjaGluZ19tZXRyaWNfcHJvY2Vzc29yKCRleHBvcnRlcik7CiAqICRsb2dQcm9jZXNzb3IgPSBiYXRjaGluZ19sb2dfcHJvY2Vzc29yKCRleHBvcnRlcik7CiAqIGBgYAogKgogKiBAcGFyYW0gVHJhbnNwb3J0ICR0cmFuc3BvcnQgVGhlIHRyYW5zcG9ydCBmb3Igc2VuZGluZyB0ZWxlbWV0cnkgZGF0YQogKiBAcGFyYW0gRXJyb3JIYW5kbGVyICRlcnJvckhhbmRsZXIgSGFuZGxlciBmb3IgVGhyb3dhYmxlcyByYWlzZWQgYnkgdGhlIHRyYW5zcG9ydAogKi8="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":217,"slug":"otlp-tracer-provider","name":"otlp_tracer_provider","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"processor","type":[{"name":"SpanProcessor","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"sampler","type":[{"name":"Sampler","namespace":"Flow\\Telemetry\\Tracer\\Sampler","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Tracer\\Sampler\\ParentBasedSampler::..."},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Context\\MemoryContextStorage::..."}],"return_type":[{"name":"TracerProvider","namespace":"Flow\\Telemetry\\Tracer","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIHRyYWNlciBwcm92aWRlciBjb25maWd1cmVkIGZvciBPVExQIGV4cG9ydC4KICoKICogQHBhcmFtIFNwYW5Qcm9jZXNzb3IgJHByb2Nlc3NvciBUaGUgcHJvY2Vzc29yIGZvciBoYW5kbGluZyBzcGFucwogKiBAcGFyYW0gQ2xvY2tJbnRlcmZhY2UgJGNsb2NrIFRoZSBjbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gU2FtcGxlciAkc2FtcGxlciBUaGUgc2FtcGxlciBmb3IgZGVjaWRpbmcgd2hldGhlciB0byByZWNvcmQgc3BhbnMKICogQHBhcmFtIENvbnRleHRTdG9yYWdlICRjb250ZXh0U3RvcmFnZSBUaGUgY29udGV4dCBzdG9yYWdlIGZvciBwcm9wYWdhdGluZyB0cmFjZSBjb250ZXh0CiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":234,"slug":"otlp-meter-provider","name":"otlp_meter_provider","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"processor","type":[{"name":"MetricProcessor","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"temporality","type":[{"name":"AggregationTemporality","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Meter\\AggregationTemporality::..."}],"return_type":[{"name":"MeterProvider","namespace":"Flow\\Telemetry\\Meter","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIG1ldGVyIHByb3ZpZGVyIGNvbmZpZ3VyZWQgZm9yIE9UTFAgZXhwb3J0LgogKgogKiBAcGFyYW0gTWV0cmljUHJvY2Vzc29yICRwcm9jZXNzb3IgVGhlIHByb2Nlc3NvciBmb3IgaGFuZGxpbmcgbWV0cmljcwogKiBAcGFyYW0gQ2xvY2tJbnRlcmZhY2UgJGNsb2NrIFRoZSBjbG9jayBmb3IgdGltZXN0YW1wcwogKiBAcGFyYW0gQWdncmVnYXRpb25UZW1wb3JhbGl0eSAkdGVtcG9yYWxpdHkgVGhlIGFnZ3JlZ2F0aW9uIHRlbXBvcmFsaXR5IGZvciBtZXRyaWNzCiAqLw=="},{"repository_path":"src\/bridge\/telemetry\/otlp\/src\/Flow\/Bridge\/Telemetry\/OTLP\/DSL\/functions.php","start_line_in_file":250,"slug":"otlp-logger-provider","name":"otlp_logger_provider","namespace":"Flow\\Bridge\\Telemetry\\OTLP\\DSL","parameters":[{"name":"processor","type":[{"name":"LogProcessor","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"clock","type":[{"name":"ClockInterface","namespace":"Psr\\Clock","is_nullable":false,"is_variadic":false}],"has_default_value":false,"is_nullable":false,"is_variadic":false,"default_value":null},{"name":"contextStorage","type":[{"name":"ContextStorage","namespace":"Flow\\Telemetry\\Context","is_nullable":false,"is_variadic":false}],"has_default_value":true,"is_nullable":false,"is_variadic":false,"default_value":"Flow\\Telemetry\\Context\\MemoryContextStorage::..."}],"return_type":[{"name":"LoggerProvider","namespace":"Flow\\Telemetry\\Logger","is_nullable":false,"is_variadic":false}],"attributes":[{"name":"DocumentationDSL","namespace":"Flow\\Documentation\\Attribute","arguments":{"module":"TELEMETRY_OTLP","type":"HELPER"}}],"scalar_function_chain":false,"doc_comment":"LyoqCiAqIENyZWF0ZSBhIGxvZ2dlciBwcm92aWRlciBjb25maWd1cmVkIGZvciBPVExQIGV4cG9ydC4KICoKICogQHBhcmFtIExvZ1Byb2Nlc3NvciAkcHJvY2Vzc29yIFRoZSBwcm9jZXNzb3IgZm9yIGhhbmRsaW5nIGxvZyByZWNvcmRzCiAqIEBwYXJhbSBDbG9ja0ludGVyZmFjZSAkY2xvY2sgVGhlIGNsb2NrIGZvciB0aW1lc3RhbXBzCiAqIEBwYXJhbSBDb250ZXh0U3RvcmFnZSAkY29udGV4dFN0b3JhZ2UgVGhlIGNvbnRleHQgc3RvcmFnZSBmb3IgcHJvcGFnYXRpbmcgY29udGV4dAogKi8="}]
\ No newline at end of file