yggio 0.0.14 → 0.0.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/binding.d.ts CHANGED
@@ -1,5 +1,9 @@
1
1
  export {
2
2
  ai,
3
+ distance,
4
+ mysql,
5
+ Connection,
6
+ Cursor,
3
7
  Arn,
4
8
  BatchReader,
5
9
  CellRange,
@@ -29,15 +33,14 @@ export {
29
33
  Plan,
30
34
  ProtocolField,
31
35
  RecordOptions,
32
- StreamSerie,
36
+ SerieChunks,
33
37
  KeySerie,
34
38
  KeySeries,
35
39
  StreamKeySerie,
36
40
  Selector,
37
- StreamChunkedSerie,
38
41
  SpillOptions,
39
42
  Parallelism,
40
- ArrowCastPlan,
43
+ CastPlan,
41
44
  StringEnum,
42
45
  Term,
43
46
  TextLine,
@@ -65,6 +68,9 @@ export {
65
68
  type FixDirection,
66
69
  type FixEntryView,
67
70
  type FixHeaderView,
71
+ type FixReport,
72
+ type FixReportParameter,
73
+ type FixRule,
68
74
  type FixSourceOptions,
69
75
  type FixSourceView,
70
76
  type HttpContentRange,
@@ -92,6 +98,8 @@ export {
92
98
  import type {
93
99
  Arn,
94
100
  BatchReader,
101
+ Connection,
102
+ Cursor,
95
103
  Bound,
96
104
  BoundSelector,
97
105
  ByteIterator,
@@ -108,6 +116,8 @@ import type {
108
116
  Field,
109
117
  FieldPath,
110
118
  Filter,
119
+ FixReport,
120
+ FixRule,
111
121
  IOBase,
112
122
  IOCursor,
113
123
  IOResult,
@@ -121,17 +131,16 @@ import type {
121
131
  ProtocolField,
122
132
  Plan,
123
133
  RecordOptions,
124
- StreamSerie,
134
+ SerieChunks,
125
135
  KeySerie,
126
136
  KeySeries,
127
137
  StreamKeySerie,
128
138
  Selector,
129
139
  Serie as NativeSerie,
130
- StreamChunkedSerie,
131
140
  SpillOptions,
132
141
  SpillStats,
133
142
  WindowSerie as NativeWindowSerie,
134
- ArrowCastPlan,
143
+ CastPlan,
135
144
  JoinOptionsInput,
136
145
  PartitionOptionsInput,
137
146
  StringParametersInput,
@@ -174,9 +183,9 @@ import {
174
183
  Compaction,
175
184
  DataFile,
176
185
  MarketMessage,
177
- FixCodec,
186
+ MarketMessagesOptions,
178
187
  FixRegistry,
179
- FixMessages,
188
+ MarketMessages,
180
189
  MsgType,
181
190
  Underlyings,
182
191
  IcebergOptions,
@@ -324,9 +333,9 @@ export type {
324
333
  Compaction,
325
334
  DataFile,
326
335
  MarketMessage,
327
- FixCodec,
336
+ MarketMessagesOptions,
328
337
  FixRegistry,
329
- FixMessages,
338
+ MarketMessages,
330
339
  MsgType,
331
340
  Underlyings,
332
341
  IcebergOptions,
@@ -683,7 +692,15 @@ export type BytesDataTypeId =
683
692
 
684
693
  /** Core compatibility targets supported by DataType and Field projection. */
685
694
  export type CompatibilityScheme =
686
- 'arrow' | 'spark' | 'polars' | 'pandas' | 'iceberg' | 'doris'
695
+ | 'arrow'
696
+ | 'spark'
697
+ | 'polars'
698
+ | 'pandas'
699
+ | 'iceberg'
700
+ | 'postgres'
701
+ | 'sqlserver'
702
+ | 'doris'
703
+ | 'mysql'
687
704
 
688
705
  /** Required intent for a generic record-write entry point. */
689
706
  export type IOMode = 'overwrite' | 'append' | 'merge' | 'readonly' | 'random'
@@ -789,7 +806,7 @@ declare module './index' {
789
806
  /** Native rows in, native rows out: a `Scalar` sequence of records, or plain objects. */
790
807
  interface RecordAppliers {
791
808
  /** The native rows this publishes, bound once against `schema` or the first record. */
792
- applyRecords(rows: Scalar | Iterable<unknown>, schema?: FieldLike | null): StreamSerie
809
+ applyRecords(rows: Scalar | Iterable<unknown>, schema?: FieldLike | null): Serie
793
810
  }
794
811
 
795
812
  interface Term {
@@ -850,6 +867,12 @@ declare module './index' {
850
867
  interface Plan extends ArrowAppliers, RecordAppliers {
851
868
  /** Return the structural document for JavaScript JSON serialization. */
852
869
  toJSON(): unknown
870
+ /**
871
+ * This plan with every parameter it names - in every section and every
872
+ * plan it holds - replaced by the value the record holds for it; the
873
+ * record names exactly the plan's parameters, ASCII case-insensitively.
874
+ */
875
+ bind(parameters?: Readonly<Record<string, unknown>> | Scalar | null): Plan
853
876
  }
854
877
 
855
878
  interface Expression extends ArrowAppliers, RecordAppliers {
@@ -857,13 +880,7 @@ declare module './index' {
857
880
  toJSON(): unknown
858
881
  }
859
882
 
860
- interface StreamSerie extends Iterator<Scalar>, Iterable<Scalar> {
861
- /** The next row, or done once every row was yielded. */
862
- next(): IteratorResult<Scalar>
863
- /** Every remaining row, as an array. */
864
- collect(): Scalar[]
865
- [Symbol.iterator](): StreamSerie
866
- }
883
+ interface SerieChunks extends IterableIterator<Serie> {}
867
884
 
868
885
  interface StringEnum {
869
886
  /**
@@ -890,6 +907,11 @@ declare module './index' {
890
907
  * order, then the components and the groups.
891
908
  */
892
909
  [Symbol.iterator](): Generator<Field>
910
+ /**
911
+ * The plugin dictionary's rows: one `Serie` under `fixPluginField()`,
912
+ * in id order - what a store keeps as `plugins.json`. A copy.
913
+ */
914
+ plugins(): Serie
893
915
  }
894
916
 
895
917
  interface MarketMessage {
@@ -897,54 +919,49 @@ declare module './index' {
897
919
  [Symbol.iterator](): IterableIterator<FixEntryView>
898
920
  }
899
921
 
900
- interface FixMessages extends IterableIterator<MarketMessage> {
922
+ interface MarketMessages extends IterableIterator<MarketMessage> {
901
923
  next(): IteratorResult<MarketMessage>
902
- }
903
- interface FixCodec {
904
924
  /**
905
- * A stream of captured lines, pulled one line at a time as the stream is
906
- * read; each line is read as `parseLine` reads it.
925
+ * The messages a stream of captured lines states, pulled one line at a
926
+ * time as the stream is read: each line's format sniffed and its
927
+ * messages split and placed. A line that is not a row at all is passed
928
+ * over with a warning; a failure of the iterable ends the stream after
929
+ * the messages before it, and `next` throws it as itself.
907
930
  */
908
- parseLines(lines: Iterable<string | ArrayBufferLike | ArrayBufferView>): FixMessages
909
- /** A stream of lines, pulled one at a time; each as `parseTextLine` reads it. */
910
- parseTextLines(lines: Iterable<TextLine>): FixMessages
931
+ fromLines(lines: Iterable<string | ArrayBufferLike | ArrayBufferView>): MarketMessages
932
+ /** A stream of decoded lines, pulled one at a time; each as `MarketMessage.fromTextLine` reads it. */
933
+ fromTextLines(lines: Iterable<TextLine>): MarketMessages
934
+ /** The messages in hand, pulled one at a time. */
935
+ fromItems(messages: Iterable<MarketMessage>): MarketMessages
911
936
  /**
912
- * The one walk over a whole stream of messages, lazily: sorted by
913
- * instant, every message but a batch container and the session
914
- * administration walked as the statement after the version its chain -
915
- * its market data kind and cross hash code - holds, through
916
- * `withPrevious` (its `prevuuid`, `prevtransunix` and `prevstate`), and
917
- * yielded only where its content code or state moved; a copy folds into
918
- * the held version by content code. The capture is collected and sorted
919
- * whole, unless `sortedLifecycle` states it arrives in instant order:
920
- * then it is read as it comes, one epoch hour held at a time.
937
+ * The messages a stream of batches of rows holds, each row one message
938
+ * rebuilt with no line parsed again, under `field`, else the reader's
939
+ * own root. The source is whatever `BatchReader.from` accepts.
921
940
  */
922
- lifecycle(messages: Iterable<MarketMessage>): FixMessages
941
+ fromArrowReader(source: BatchSource, field?: FieldLike | null): MarketMessages
942
+ /** A stream of batches of capture rows, each row read as a line, its own columns carried. */
943
+ fromTextArrowReader(source: BatchSource): MarketMessages
944
+ /** The stream as batches of rows under `field`, else under its own root. */
945
+ intoArrowReader(field?: FieldLike | null): BatchReader
946
+ /** The stream's messages as rows, a `Serie` read lazily, under `field`, else its own root. */
947
+ intoSerie(field?: FieldLike | null): Serie
948
+ }
949
+
950
+ interface Underlyings {
923
951
  /**
924
- * A stream of messages as batches of FIX rows under `schema`, closed on
925
- * the codec's `batchRowSize` rows or its `batchByteSize` laid bytes,
926
- * whichever a batch reaches first.
952
+ * Every row the table holds now, in code order: the seed's and every
953
+ * row a parse given the table filled or created, under
954
+ * `fixUnderlyingField()`.
927
955
  */
928
- arrowReader(schema: Field, messages: Iterable<MarketMessage>): BatchReader
956
+ rows(): Serie
929
957
  /**
930
- * A stream of messages as the rows one message field holds them.
931
- *
932
- * The third verb, and the one a consumer reads by: `parse*` turns a
933
- * capture into messages, `lifecycle` states what each follows, and this
934
- * answers them under whatever field a consumer reads by - a venue's own
935
- * message type, `MarketMessage.field()`, the message row, or any Struct
936
- * root a caller built. Each column binds as a
937
- * lookup binds its name, so a column the message does not state is
938
- * null, and a message leaving a column that cannot be null empty is
939
- * passed over with a warning.
958
+ * The one message search: `text` read against this table, the plugins
959
+ * of `options.registry` where one is given and the root `field` - any
960
+ * `FieldLike` - into one plan over the message rows, the window
961
+ * `[since, until)` on `markettimestamp` at the top, newest first; `null` for
962
+ * a blank text.
940
963
  */
941
- formatMessages(messages: Iterable<MarketMessage>, field: Field): Scalar[]
942
- /** The batch twins take whatever `BatchReader.from` accepts. */
943
- parseTextArrowReader(source: BatchSource): BatchReader
944
- lifecycleArrowReader(source: BatchSource): BatchReader
945
- formatArrowReader(source: BatchSource, field: Field): BatchReader
946
- messages(source: BatchSource): FixMessages
947
- writeArrowReader(source: BatchSource, sink: { write(chunk: Uint8Array): unknown }): number
964
+ messageSearch(text: string, field: FieldLike, options?: MessageSearchOptions): Plan | null
948
965
  }
949
966
 
950
967
  interface Field {
@@ -954,7 +971,13 @@ declare module './index' {
954
971
  }
955
972
 
956
973
  namespace Serie {
957
- function from(value: unknown, field?: FieldLike | null, options?: ArrowCastOptions): Serie
974
+ /**
975
+ * Sort a serie whose chunks arrive as non-overlapping spans, one span
976
+ * in memory at a time: `by` is bound and checked before the first span
977
+ * is pulled, then each span is sorted on its own as the output advances.
978
+ */
979
+ function fromSortedSpans(spans: Iterable<Serie | ChunkedSerie | BatchReader>, by: OrderingKeys): Serie
980
+ function from(value: unknown, field?: FieldLike | null, options?: CastOptions): Serie
958
981
  /** The column `field` types `rows` into, each through the field's own contract. */
959
982
  function fromScalars(field: Field | string, rows: Iterable<unknown>): Serie
960
983
  /** The empty column of `field`. */
@@ -978,7 +1001,7 @@ declare module './index' {
978
1001
  function fromArrowArray(
979
1002
  vector: ArrowVector,
980
1003
  field?: Field | string,
981
- options?: ArrowCastOptions,
1004
+ options?: CastOptions,
982
1005
  ): Serie
983
1006
  /**
984
1007
  * One Apache Arrow JS record batch or table as the record column of its
@@ -987,16 +1010,20 @@ declare module './index' {
987
1010
  function fromArrowBatch(
988
1011
  batch: ArrowRecordBatch | ArrowTable,
989
1012
  root?: Field | string,
990
- options?: ArrowCastOptions,
1013
+ options?: CastOptions,
991
1014
  ): Serie
992
1015
  /**
993
- * Drain a native reader into the record column of its rows, every batch
994
- * cast by one plan; the reader is consumed.
1016
+ * A native reader as one lazy record column of its rows: of its own
1017
+ * schema, or cast into `root` by one plan compiled here, and nothing
1018
+ * pulled at the call. Each batch is cast as a read pulls it -
1019
+ * `intoChunks` one record column per batch - a refused batch thrown by
1020
+ * the pull that reaches it, after the batches before it. The reader is
1021
+ * consumed.
995
1022
  */
996
1023
  function fromArrowReader(
997
1024
  reader: BatchReader,
998
1025
  root?: Field | string,
999
- options?: ArrowCastOptions,
1026
+ options?: CastOptions,
1000
1027
  ): Serie
1001
1028
  }
1002
1029
 
@@ -1045,7 +1072,7 @@ declare module './index' {
1045
1072
  * This column under `field` - a DataType as its required `value` field -
1046
1073
  * cast once; a run is refused.
1047
1074
  */
1048
- cast(field: Field | DataType | string, options?: ArrowCastOptions): Serie
1075
+ cast(field: Field | DataType | string, options?: CastOptions): Serie
1049
1076
  /** This one-row column as the Apache Arrow JS value of its row. */
1050
1077
  intoArrowScalar(): unknown
1051
1078
  /** This column as one Apache Arrow JS vector. */
@@ -1082,7 +1109,11 @@ declare module './index' {
1082
1109
  */
1083
1110
  intoFiltered(mask: SerieArgument): Serie
1084
1111
  /** Native key partitions; the payload retains its own layout. */
1085
- partitionBy(by: WindowKey): KeySeries
1112
+ partitionBy(by: WindowKey, options?: PartitionOptionsInput | null): KeySeries
1113
+ /** This serie walked one record column per batch. */
1114
+ intoChunks(): SerieChunks
1115
+ /** This serie cast into `field` by one plan, lazily where it is lazy. */
1116
+ intoCast(field: Field | DataType | string, options?: CastOptions): Serie
1086
1117
  /**
1087
1118
  * Sort the rows in place under `options` and answer this serie, so calls
1088
1119
  * chain: a primitive column holding its buffer alone sorts where it
@@ -1223,101 +1254,14 @@ declare module './index' {
1223
1254
  asSortBy(by: OrderingKeys): this
1224
1255
  }
1225
1256
 
1226
- namespace StreamChunkedSerie {
1227
- /**
1228
- * Read a native reader's batches as record series: of its own schema,
1229
- * named `row`, or cast into `root` by one plan compiled here. The reader
1230
- * is consumed.
1231
- */
1232
- function fromArrowReader(
1233
- reader: BatchReader,
1234
- root?: Field | string,
1235
- options?: ArrowCastOptions,
1236
- ): StreamChunkedSerie
1237
- /**
1238
- * Read one held column as a stream of the one record serie it is: a
1239
- * record column as it stands, any other column as the one child of a
1240
- * record named `row`. A run, and a record column with an absent row,
1241
- * are refused.
1242
- */
1243
- function fromSerie(serie: Serie): StreamChunkedSerie
1244
- /**
1245
- * Read a held chunked column as the stream of its chunks, one record
1246
- * serie per chunk: a record's chunks as they stand, any other field's
1247
- * each the one child of a record named `row`. Nothing is cast or copied;
1248
- * a record chunk with an absent row is refused.
1249
- */
1250
- function fromChunked(chunked: ChunkedSerie): StreamChunkedSerie
1251
- /**
1252
- * Sort a stream whose chunks arrive as non-overlapping spans, one span
1253
- * in memory at a time: `by` is bound and checked before the first span
1254
- * is pulled, then the first span is pulled for its root field and each
1255
- * span is sorted on its own as the output advances.
1256
- */
1257
- function fromSortedSpans(
1258
- spans: Iterable<StreamChunkedSerie | ChunkedSerie | Serie | BatchReader>,
1259
- by: OrderingKeys,
1260
- ): StreamChunkedSerie
1261
- }
1262
-
1263
- interface StreamChunkedSerie extends Iterable<Serie> {
1264
- readonly schema: import('apache-arrow').Schema
1265
- readNextBatch(): ArrowRecordBatch | null
1266
- readAll(): ArrowTable
1267
- /** One record serie per batch, each cast as it is pulled. */
1268
- [Symbol.iterator](): Generator<Serie, void, undefined>
1269
- /**
1270
- * Every record this reader yields cast into `field` by one plan: a
1271
- * record root, or a column - a DataType as its required `value` field -
1272
- * as the one child of a record named `row`. This reader's own root
1273
- * answers it as it stands; held records are cast here, once each, and a
1274
- * stream's batches as they are pulled. The reader is consumed.
1275
- */
1276
- cast(field: Field | DataType | string, options?: ArrowCastOptions): StreamChunkedSerie
1277
- /** Adjacent key contexts and native payloads. */
1278
- windowBy(by: WindowKey, sorted?: boolean | null): StreamKeySerie
1279
- /** Native key partitions; the payload retains its own layout. */
1280
- partitionBy(by: WindowKey, options?: PartitionOptionsInput | null): StreamKeySerie
1281
- intoSorted(options?: SortOptions | null): StreamChunkedSerie
1282
- /**
1283
- * Every record this reader yields in the order the `order by` keys of
1284
- * `by` state, bound against the root before any batch is pulled, then
1285
- * drained and merged as `intoSorted` is. The reader is consumed, a
1286
- * refused key included.
1287
- */
1288
- intoSortBy(by: OrderingKeys): StreamChunkedSerie
1289
- /**
1290
- * This stream joined with `other` - a Serie, a ChunkedSerie, or another
1291
- * StreamChunkedSerie, consumed too - on `by`, under `how` (`inner` when absent
1292
- * or null): a stream of the output, one probe batch joined at a time,
1293
- * the held side built and hashed first, `Serie.joinWith`'s rules for the
1294
- * columns. `how` and `options` are read before anything is consumed;
1295
- * this reader is consumed, a refused key included.
1296
- */
1297
- joinWith(
1298
- other: Serie | ChunkedSerie | StreamChunkedSerie,
1299
- by: JoinKeys,
1300
- how?: JoinHow | null,
1301
- options?: JoinOptionsInput | null,
1302
- ): StreamChunkedSerie
1303
- /**
1304
- * Spill the records this reader holds in place under the bound `options`
1305
- * states, as `spill` does, and answer this reader; a stream holds none
1306
- * and is untouched. Refused once the reader was consumed.
1307
- */
1308
- asSpilled(options?: SpillOptions | null): this
1309
- /**
1310
- * This reader with the records it holds spilled under the bound
1311
- * `options` states, handed over as a new reader: a stream moves rather
1312
- * than copies, so this reader is consumed.
1313
- */
1314
- intoSpilled(options?: SpillOptions | null): StreamChunkedSerie
1315
- }
1316
-
1317
1257
  namespace ChunkedSerie {
1318
1258
  /** The chunked serie of no chunks under `field`. */
1319
1259
  function empty(field: Field | string): ChunkedSerie
1320
- /** One held column as its one chunk, sharing its buffers; a run is refused. */
1260
+ /**
1261
+ * The rows held apart as the chunks they are: a chunked serie's own, a
1262
+ * lazy stream's batches one chunk each, an empty column no chunk, any
1263
+ * other column its one chunk, sharing its buffers; a run is refused.
1264
+ */
1321
1265
  function fromSerie(serie: Serie): ChunkedSerie
1322
1266
  /**
1323
1267
  * Held columns as chunks under one field. With no field they are one
@@ -1329,7 +1273,7 @@ declare module './index' {
1329
1273
  function fromSeries(
1330
1274
  chunks: Iterable<Serie>,
1331
1275
  field?: Field | string,
1332
- options?: ArrowCastOptions,
1276
+ options?: CastOptions,
1333
1277
  ): ChunkedSerie
1334
1278
  /**
1335
1279
  * One Apache Arrow JS vector as one chunk per `Data` it holds: of its
@@ -1339,7 +1283,7 @@ declare module './index' {
1339
1283
  function fromArrowArray(
1340
1284
  vector: ArrowVector,
1341
1285
  field?: Field | string,
1342
- options?: ArrowCastOptions,
1286
+ options?: CastOptions,
1343
1287
  ): ChunkedSerie
1344
1288
  /**
1345
1289
  * One Apache Arrow JS table as one record chunk per batch, and one
@@ -1349,7 +1293,7 @@ declare module './index' {
1349
1293
  function fromArrowBatch(
1350
1294
  batch: ArrowRecordBatch | ArrowTable,
1351
1295
  root?: Field | string,
1352
- options?: ArrowCastOptions,
1296
+ options?: CastOptions,
1353
1297
  ): ChunkedSerie
1354
1298
  /**
1355
1299
  * Drain a native reader, one record chunk per batch, every batch cast
@@ -1358,7 +1302,7 @@ declare module './index' {
1358
1302
  function fromArrowReader(
1359
1303
  reader: BatchReader,
1360
1304
  root?: Field | string,
1361
- options?: ArrowCastOptions,
1305
+ options?: CastOptions,
1362
1306
  ): ChunkedSerie
1363
1307
  }
1364
1308
 
@@ -1377,14 +1321,14 @@ declare module './index' {
1377
1321
  * Append one column as a chunk: under the field as it stands, any other
1378
1322
  * cast into it; a refusal leaves the chunks as they were.
1379
1323
  */
1380
- pushChunk(chunk: Serie, options?: ArrowCastOptions): void
1324
+ pushChunk(chunk: Serie, options?: CastOptions): void
1381
1325
  /** Every row as one column: the one join. */
1382
1326
  intoSerie(): Serie
1383
1327
  /**
1384
1328
  * Every chunk under `field` - a DataType as its required `value` field -
1385
1329
  * by one plan.
1386
1330
  */
1387
- cast(field: Field | DataType | string, options?: ArrowCastOptions): ChunkedSerie
1331
+ cast(field: Field | DataType | string, options?: CastOptions): ChunkedSerie
1388
1332
  /**
1389
1333
  * One Apache Arrow JS vector holding one `Data` per chunk. Arrow JS
1390
1334
  * holds no vector of no `Data`, so a chunked serie of no chunk is a
@@ -1474,7 +1418,7 @@ declare module './index' {
1474
1418
  const NEVER: bigint
1475
1419
  }
1476
1420
 
1477
- namespace ArrowCastPlan {
1421
+ namespace CastPlan {
1478
1422
  /**
1479
1423
  * Compile the cast from `source` to `target` once. An Apache Arrow JS
1480
1424
  * schema, table or batch names its source by its schema, imported as the
@@ -1483,17 +1427,17 @@ declare module './index' {
1483
1427
  function compile(
1484
1428
  source: Field | string | ArrowSchema | ArrowTable | ArrowRecordBatch,
1485
1429
  target: Field | string,
1486
- options?: ArrowCastOptions,
1487
- ): ArrowCastPlan
1430
+ options?: CastOptions,
1431
+ ): CastPlan
1488
1432
  }
1489
1433
 
1490
- interface ArrowCastPlan {
1434
+ interface CastPlan {
1491
1435
  /** Cast one column laid out as `source`. */
1492
1436
  apply(serie: Serie): Serie
1493
1437
  /** Cast every chunk of a chunked column laid out as `source`, kept apart. */
1494
1438
  apply(chunked: ChunkedSerie): ChunkedSerie
1495
1439
  /** The two cast answers this plan was compiled under. */
1496
- readonly options: Readonly<Required<ArrowCastOptions>>
1440
+ readonly options: Readonly<Required<CastOptions>>
1497
1441
  }
1498
1442
 
1499
1443
  interface Xxh32 {
@@ -3805,24 +3749,24 @@ export declare const enums: {
3805
3749
  /**
3806
3750
  * The six element column names every generated schema opens with, in
3807
3751
  * schema order: `uuid`, `crossuuid`, `crosscode`, `hashcode`,
3808
- * `crosshashcode`, `srcuuids`.
3752
+ * `crosshashcode`, `sourceuuids`.
3809
3753
  */
3810
3754
  readonly elementColumns: readonly string[]
3811
3755
  /**
3812
3756
  * The ten event column names that follow them, in schema order:
3813
- * `transunix`, `creaunix`, `techunix`, `exprunix`, `prevtransunix`,
3814
- * `snapunix`, `seqnum`, `prevuuid`, `state`, `prevstate`.
3757
+ * `markettimestamp`, `creationtimestamp`, `technicaltimestamp`, `expirytimestamp`, `previousmarkettimestamp`,
3758
+ * `snapshottimestamp`, `sequencenumber`, `previousuuid`, `state`, `previousstate`.
3815
3759
  */
3816
3760
  readonly eventColumns: readonly string[]
3817
3761
  /**
3818
3762
  * The forty-two market column names, in schema order:
3819
- * `marketdatakind`, `marketdatatype`, `ack`, `conversationid`,
3820
- * `securityids`, `cficode`, `mic`, `undcode`, `undcat`, `side`, `quantity`,
3821
- * `prevqty`, `displayqty`, `hiddenqty`, `unitofmeasure`, `roundlot`, `currency`,
3822
- * `origccy`, `price`, `prevpx`, `stoppx`, `strikeprice`, `execunix`,
3763
+ * `marketdatakind`, `marketdatatype`, `acknowledgement`, `conversationid`,
3764
+ * `securityids`, `cficode`, `mic`, `underlyingcode`, `underlyingcategory`, `side`, `quantity`,
3765
+ * `previousquantity`, `displayqty`, `hiddenqty`, `unitofmeasure`, `roundlot`, `currency`,
3766
+ * `origincurrency`, `price`, `previousprice`, `stoppx`, `strikeprice`, `lastexecutiontimestamp`,
3823
3767
  * `lastpx`, `lastqty`, `avgpx`, `cumqty`, `leavesqty`, `cxlqty`,
3824
- * `lastspotrate`, `lastforwardpoints`, `bidpx`, `bidsize`, `bidccy`, `offerpx`,
3825
- * `offersize`, `offerccy`, `bidspotrate`, `bidforwardpoints`, `offerspotrate`,
3768
+ * `lastspotrate`, `lastforwardpoints`, `bidpx`, `bidsize`, `bidcurrency`, `offerpx`,
3769
+ * `offersize`, `offercurrency`, `bidspotrate`, `bidforwardpoints`, `offerspotrate`,
3826
3770
  * `offerforwardpoints`, `targetfxrates`.
3827
3771
  */
3828
3772
  readonly marketColumns: readonly string[]
@@ -4429,7 +4373,7 @@ declare module './index' {
4429
4373
  readSerie(options?: RecordOptionsInput | RecordProperties | null, properties?: RecordProperties | null): Serie
4430
4374
  /**
4431
4375
  * Write rows in any shape they are held - a Serie, a ChunkedSerie, a
4432
- * StreamChunkedSerie (consumed), or any value `BatchReader.from` accepts -
4376
+ * keyed or windowed serie, or any value `BatchReader.from` accepts -
4433
4377
  * under `mode`, `overwrite` when absent. A structured text document
4434
4378
  * takes `overwrite` alone, and of the options the declared field alone.
4435
4379
  */
@@ -4516,10 +4460,19 @@ declare module './index' {
4516
4460
  streamBytes(batchSize?: number | null): ByteIterator
4517
4461
  }
4518
4462
 
4519
- /** Iterating a reader yields one Apache Arrow JS record batch at a time. */
4520
- interface BatchReader extends Iterable<ArrowRecordBatch> {
4463
+ /**
4464
+ * Iterating a reader yields one Apache Arrow JS record batch at a time:
4465
+ * `for...of` pulls each on the calling thread, `for await` on the libuv
4466
+ * pool - one stream, read once by either.
4467
+ */
4468
+ interface BatchReader extends Iterable<ArrowRecordBatch>, AsyncIterable<ArrowRecordBatch> {
4521
4469
  /** Drain every remaining batch into one Apache Arrow JS table. */
4522
4470
  intoTable(): ArrowTable
4471
+ /**
4472
+ * Each batch as its own Arrow IPC stream (schema, batch, end of stream),
4473
+ * pulled on the libuv pool, for a server to forward without decoding.
4474
+ */
4475
+ ipcBatches(): AsyncIterableIterator<Buffer>
4523
4476
  }
4524
4477
  namespace BatchReader {
4525
4478
  /** Build a reader from a reader, an Arrow JS value, or Arrow IPC bytes. */
@@ -4653,7 +4606,7 @@ export type Representation = 'value' | 'bits'
4653
4606
  * column refuses one by path. An absent answer takes the core's default:
4654
4607
  * safe, `"value"`.
4655
4608
  */
4656
- export interface ArrowCastOptions {
4609
+ export interface CastOptions {
4657
4610
  safe?: boolean
4658
4611
  representation?: Representation
4659
4612
  }
@@ -4719,7 +4672,7 @@ export type JoinKeys =
4719
4672
  * `full`.
4720
4673
  */
4721
4674
  export type JoinHow = 'inner' | 'left' | 'right' | 'full' | 'outer' | 'semi' | 'anti' | (string & {})
4722
- export type NativeSerieInput = Serie | ChunkedSerie | WindowSerie | StreamSerie | StreamChunkedSerie | KeySerie | KeySeries | StreamKeySerie
4675
+ export type NativeSerieInput = Serie | ChunkedSerie | WindowSerie | KeySerie | KeySeries | StreamKeySerie
4723
4676
  export type WindowKey = Selector | Term | string | readonly (Term | string)[] | FieldPath | readonly FieldPath[] | NativeSerieInput | ArrowVector | ArrowTable | ArrowRecordBatch
4724
4677
 
4725
4678
  /** The field paths a record partitions by: one path, its text, or an iterable of them. */
@@ -5194,9 +5147,42 @@ export type FixValueInput =
5194
5147
  * built by a factory, never by `new`.
5195
5148
  */
5196
5149
  export interface MarketMessageStatic extends Function {
5150
+ /**
5151
+ * The one message a captured line states, its format sniffed, under
5152
+ * `options`, `MarketMessagesOptions.fromEnv()` when none are given. A
5153
+ * line stating no message, and a line carrying a second frame, throws:
5154
+ * `MarketMessages.fromLines` reads a line's every message.
5155
+ */
5156
+ fromLine(
5157
+ row: string | ArrayBufferLike | ArrayBufferView,
5158
+ options?: MarketMessagesOptions | null,
5159
+ ): MarketMessage
5160
+ /**
5161
+ * The one message a line a text reader answered states: its body and its
5162
+ * row-header captures, named by the options' `captureNames`.
5163
+ */
5164
+ fromTextLine(line: TextLine, options?: MarketMessagesOptions | null): MarketMessage
5165
+ /** One numeric FIX frame, read by the pairs it states. */
5166
+ fromFixMessage(
5167
+ body: string | ArrayBufferLike | ArrayBufferView,
5168
+ options?: MarketMessagesOptions | null,
5169
+ ): MarketMessage
5170
+ /** One bridge frame, whose keys are names rather than tags. */
5171
+ fromUllinkLine(
5172
+ body: string | ArrayBufferLike | ArrayBufferView,
5173
+ options?: MarketMessagesOptions | null,
5174
+ ): MarketMessage
5175
+ /** One FIXML message, whose fields are XML attributes. */
5176
+ fromFixmlMessage(
5177
+ body: string | ArrayBufferLike | ArrayBufferView,
5178
+ options?: MarketMessagesOptions | null,
5179
+ ): MarketMessage
5180
+ /** Pairs a caller already holds, in the order they arrived. */
5181
+ fromPairs(pairs: Array<[string, string]>, options?: MarketMessagesOptions | null): MarketMessage
5197
5182
  /**
5198
5183
  * A FIX record - a struct root and its row - read as the parse reads one,
5199
- * under the process default registry when none is named. A child stating
5184
+ * under `options`, `MarketMessagesOptions.fromEnv()` when none are given.
5185
+ * A child stating
5200
5186
  * a typed fact - one of the FIX fields a message lifts, a crate column -
5201
5187
  * fills the fact that owns it and keeps its statement at its place;
5202
5188
  * `SendingTime` reads the Unix epoch when the value states none, and the
@@ -5205,14 +5191,14 @@ export interface MarketMessageStatic extends Function {
5205
5191
  fromFixRecord(
5206
5192
  field: Field,
5207
5193
  value: FixValueInput,
5208
- registry?: FixRegistry | null,
5194
+ options?: MarketMessagesOptions | null,
5209
5195
  ): MarketMessage
5210
5196
  /**
5211
5197
  * The message a row holds: the inverse of `intoRow`, each column bound as
5212
5198
  * a lookup binds its name and the residual `entries` restored without a
5213
5199
  * parse. No clock is read, and a supplied row identity is retained.
5214
5200
  */
5215
- fromRow(schema: Field, row: FixValueInput, registry?: FixRegistry | null): MarketMessage
5201
+ fromRow(schema: Field, row: FixValueInput, options?: MarketMessagesOptions | null): MarketMessage
5216
5202
  /**
5217
5203
  * The one message row, `fixmsg`: the element, event, market, operation,
5218
5204
  * source and session columns, the `trdregtimestamps` and `parties`
@@ -5230,7 +5216,7 @@ export interface Fix {
5230
5216
  * The row header a ULBridge log writes in front of every line, as a
5231
5217
  * `rowheader` for a text read. Its clock is `mtime`, so the header dates
5232
5218
  * each line it matches: the capture is consumed into the line's
5233
- * `transunix` - the `techunix` of its messages and the sending clock of one
5219
+ * `markettimestamp` - the `technicaltimestamp` of its messages and the sending clock of one
5234
5220
  * stating no `SendingTime(52)` - read at nanoseconds UTC under the text
5235
5221
  * options' `timezone`, never the file's modification time. The other
5236
5222
  * captures are `msgthreadid`, `msgeventkey` - the bracket's session,
@@ -5261,18 +5247,24 @@ export interface Fix {
5261
5247
  */
5262
5248
  readonly MarketMessage: MarketMessageStatic
5263
5249
  /**
5264
- * One dictionary, reading captured lines into settled messages, walking
5265
- * them through one lifecycle, and the Arrow twin of each - a pin is on the
5266
- * codec, a stage is a call.
5250
+ * The options a message stream reads under: one dictionary and every pin
5251
+ * a parse, a walk and a sink read. They hold no stream.
5267
5252
  */
5268
- readonly FixCodec: typeof FixCodec
5253
+ readonly MarketMessagesOptions: typeof MarketMessagesOptions
5269
5254
  /**
5270
5255
  * Immutable registry-owned message definitions; `identifierValues` returns
5271
5256
  * independent mutable declaration Fields beside native Scalar values.
5272
5257
  */
5273
5258
  readonly MsgType: abstract new () => MsgType
5274
- /** A lazy stream of messages: what every stage of `FixCodec` answers. */
5275
- readonly FixMessages: abstract new () => FixMessages
5259
+ /**
5260
+ * The handler over a stream of messages: `new MarketMessages(options?)`
5261
+ * is idle; a source (`fromLines`, `fromTextLines`, `fromItems`,
5262
+ * `fromArrowReader`, `fromTextArrowReader`) answers a new handler over its
5263
+ * stream, a stage (`intoLifecycle`, `intoLineage`) the handler over what
5264
+ * it makes of it, and a sink (`intoArrowReader`, `intoSerie`,
5265
+ * `intoWriter`) drains it.
5266
+ */
5267
+ readonly MarketMessages: typeof MarketMessages
5276
5268
  /**
5277
5269
  * The table of underlyings, its essential doors: `Underlyings.seeded()`,
5278
5270
  * `get(code)` - a code, an instrument key, an index key `{key}={value}` or
@@ -5281,8 +5273,9 @@ export interface Fix {
5281
5273
  * each once: the exact code, an identifier the key index answers (an ISIN,
5282
5274
  * a FIGI, a RIC, a Bloomberg code, `{ticker}@{MIC}`, `{MIC}:{ticker}`, a
5283
5275
  * currency pair in any spelling), then a ticker, a name or an alias,
5284
- * exact, prefix, substring - as a `Serie` under `underlyingField()`, and
5285
- * `length`.
5276
+ * exact, prefix, substring - as a `Serie` under `underlyingField()`,
5277
+ * `messageSearch(text, field, { registry, limit = 20, since, until })` -
5278
+ * the one plan over message rows a text names - and `length`.
5286
5279
  */
5287
5280
  readonly Underlyings: { seeded(): Underlyings; readonly prototype: Underlyings }
5288
5281
  /**
@@ -5300,8 +5293,8 @@ export interface Fix {
5300
5293
  crateFields(): Field[]
5301
5294
  /**
5302
5295
  * The row an `Underlyings` table stores, `underlying`: one instrument on
5303
- * one market or across every market, partitioned by `partunix` and sorted
5304
- * by `code`.
5296
+ * one market or across every market, partitioned by `months(endtimestamp)` - no
5297
+ * column of its own, a row with no end in the null partition - and sorted by `code`.
5305
5298
  */
5306
5299
  underlyingField(): Field
5307
5300
  /**
@@ -5314,10 +5307,27 @@ export interface Fix {
5314
5307
  micEntryField(): Field
5315
5308
  /** The row of GLEIF's register, `legalentity`: one LEI's Level 1 record with its parents, partitioned by `country`. */
5316
5309
  legalEntityField(): Field
5317
- /** The row a rate table stores, `fxrate`: the element and event columns, `buy`, `sell`, `rate` and `partunix`. */
5310
+ /** The row a rate table stores, `fxrate`: the element and event columns, `buy`, `sell` and `rate`, partitioned by `months(markettimestamp)`. */
5318
5311
  fxRateField(): Field
5319
5312
  /** The row of the plugin dictionary, `plugin`: one plugin a bridge logs through, its `side` the side kind's code. */
5320
5313
  pluginField(): Field
5314
+ /**
5315
+ * Every audit report `yggio_market::reports` lists, in the order a page
5316
+ * lists them - `otr`, `cancels`, `rate`, `concentration`, `execution`,
5317
+ * `completeness`, `trail` - each a fresh plain object: its `name`,
5318
+ * `title`, `description`, the `plan` naming no location, which the
5319
+ * engine opens over the table it is asked of, and the `parameters` it
5320
+ * binds, each `default` absent where the caller states the value.
5321
+ */
5322
+ reports(): FixReport[]
5323
+ /**
5324
+ * Every rule the crate applies to a FIX message, in the order
5325
+ * `yggio_market::fix::rules` lists them, each a fresh plain object: its
5326
+ * `id`, `class`, `authority` (`spec` or `crate`) and the `reference` it
5327
+ * names, the `sources` it reads and `targets` it fills as tags, and an
5328
+ * `example` FIX line, `""` where none is kept.
5329
+ */
5330
+ rules(): FixRule[]
5321
5331
  }
5322
5332
 
5323
5333
  export declare const fix: Fix
@@ -5422,9 +5432,26 @@ export interface FileSystemHandler {
5422
5432
  // The key context and payload travel separately through native stream adapters.
5423
5433
  declare module './index' {
5424
5434
  interface KeySerie { readonly rows: Serie }
5435
+ /** Iterating, `length` and `get` drain a lazy collection once; its stream's failure throws. */
5425
5436
  interface KeySeries extends Iterable<KeySerie> { [Symbol.iterator](): IterableIterator<KeySerie> }
5426
5437
  interface StreamKeySerie extends IterableIterator<KeySerie> {
5427
5438
  next(): IteratorResult<KeySerie>
5428
5439
  [Symbol.iterator](): StreamKeySerie
5429
5440
  }
5430
5441
  }
5442
+ /** What `connect` reads beside the URL: the Yggio engine's warehouse, the dialect text is read in, and every other key a session (no URL) or engine (a URL) property. */
5443
+ export type ConnectOptions = { warehouse?: Warehouse; dialect?: 'ansi' | 'doris' | 'mysql' | 'datafusion' } & Record<string, string | number | boolean | Warehouse | undefined>
5444
+ /** Open a session on the libuv pool: no URL the Yggio engine over `warehouse` (the process's SystemWarehouse by default), a URL the engine its scheme's crate answers - `mysql://` through yggio-mysql. */
5445
+ export declare function connect(url?: string | NodeURL | Url | null, options?: ConnectOptions): Promise<Connection>
5446
+ declare module './index' {
5447
+ interface Connection {
5448
+ /** Write `data` - whatever `BatchReader.from` reads - into the table `table` names by `mode`, creating it where absent (Connection::write_serie). */
5449
+ writeSerie(table: ObjectPathInput, data: BatchSource, mode?: 'overwrite' | 'append' | 'merge'): Promise<IOResult>
5450
+ }
5451
+ interface Cursor extends AsyncIterable<ArrowRecordBatch> {
5452
+ /** Run SQL text (the session's dialect) or a Plan with one record of parameters; settles with this cursor. An aborted `signal` rejects with its reason and cancels the session's statement. */
5453
+ execute(operation: string | Plan, parameters?: Scalar | Record<string, unknown> | null, options?: { signal?: AbortSignal }): Promise<Cursor>
5454
+ /** The last statement's rows drained on the libuv pool into one Apache Arrow JS table, once. */
5455
+ fetchArrowTable(): Promise<ArrowTable>
5456
+ }
5457
+ }