@elaraai/east 0.0.1-beta.26 → 0.0.1-beta.28

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.
Files changed (39) hide show
  1. package/dist/src/analyze.d.ts +3 -0
  2. package/dist/src/analyze.d.ts.map +1 -1
  3. package/dist/src/analyze.js +30 -9
  4. package/dist/src/analyze.js.map +1 -1
  5. package/dist/src/ast.d.ts +1 -0
  6. package/dist/src/ast.d.ts.map +1 -1
  7. package/dist/src/ast_to_ir.d.ts.map +1 -1
  8. package/dist/src/ast_to_ir.js +1 -0
  9. package/dist/src/ast_to_ir.js.map +1 -1
  10. package/dist/src/compile.d.ts.map +1 -1
  11. package/dist/src/compile.js +19 -3
  12. package/dist/src/compile.js.map +1 -1
  13. package/dist/src/datetime_format/types.d.ts +23 -23
  14. package/dist/src/expr/block.d.ts +133 -1
  15. package/dist/src/expr/block.d.ts.map +1 -1
  16. package/dist/src/expr/block.js +344 -0
  17. package/dist/src/expr/block.js.map +1 -1
  18. package/dist/src/expr/index.d.ts +73 -2
  19. package/dist/src/expr/index.d.ts.map +1 -1
  20. package/dist/src/expr/index.js +72 -1
  21. package/dist/src/expr/index.js.map +1 -1
  22. package/dist/src/internal.d.ts +1 -1
  23. package/dist/src/internal.d.ts.map +1 -1
  24. package/dist/src/internal.js +1 -1
  25. package/dist/src/internal.js.map +1 -1
  26. package/dist/src/ir.d.ts +1406 -1371
  27. package/dist/src/ir.d.ts.map +1 -1
  28. package/dist/src/ir.js +1 -1
  29. package/dist/src/ir.js.map +1 -1
  30. package/dist/src/platform.d.ts +6 -0
  31. package/dist/src/platform.d.ts.map +1 -1
  32. package/dist/src/serialization/csv.d.ts +17 -17
  33. package/dist/src/type_of_type.d.ts +34 -34
  34. package/dist/src/type_of_type.js +1 -1
  35. package/dist/src/type_of_type.js.map +1 -1
  36. package/dist/src/types.d.ts +8 -8
  37. package/dist/src/types.d.ts.map +1 -1
  38. package/dist/src/types.js.map +1 -1
  39. package/package.json +1 -1
package/dist/src/ir.d.ts CHANGED
@@ -222,6 +222,7 @@ export type PlatformIR = variant<"Platform", {
222
222
  type: EastTypeValue;
223
223
  location: LocationValue;
224
224
  name: string;
225
+ type_parameters: EastTypeValue[];
225
226
  arguments: any[];
226
227
  async: boolean;
227
228
  }>;
@@ -233,1537 +234,1571 @@ export type PlatformIR = variant<"Platform", {
233
234
  */
234
235
  export type IR = ErrorIR | TryCatchIR | ValueIR | VariableIR | LetIR | AssignIR | AsIR | FunctionIR | AsyncFunctionIR | CallIR | CallAsyncIR | NewRefIR | NewArrayIR | NewSetIR | NewDictIR | StructIR | GetFieldIR | VariantIR | BlockIR | IfElseIR | MatchIR | UnwrapRecursiveIR | WrapRecursiveIR | WhileIR | ForArrayIR | ForSetIR | ForDictIR | ReturnIR | ContinueIR | BreakIR | BuiltinIR | PlatformIR;
235
236
  export declare const LocationType: StructType<{
236
- filename: StringType;
237
- line: IntegerType;
238
- column: IntegerType;
237
+ readonly filename: StringType;
238
+ readonly line: IntegerType;
239
+ readonly column: IntegerType;
239
240
  }>;
240
241
  export declare const IRLabelType: StructType<{
241
- name: StringType;
242
- location: StructType<{
243
- filename: StringType;
244
- line: IntegerType;
245
- column: IntegerType;
242
+ readonly name: StringType;
243
+ readonly location: StructType<{
244
+ readonly filename: StringType;
245
+ readonly line: IntegerType;
246
+ readonly column: IntegerType;
246
247
  }>;
247
248
  }>;
248
249
  export declare const VariableType: StructType<{
249
- type: RecursiveType<VariantType<{
250
- Never: import("./types.js").NullType;
251
- Null: import("./types.js").NullType;
252
- Boolean: import("./types.js").NullType;
253
- Integer: import("./types.js").NullType;
254
- Float: import("./types.js").NullType;
255
- String: import("./types.js").NullType;
256
- DateTime: import("./types.js").NullType;
257
- Blob: import("./types.js").NullType;
258
- Ref: import("./types.js").RecursiveTypeMarker;
259
- Array: import("./types.js").RecursiveTypeMarker;
260
- Set: import("./types.js").RecursiveTypeMarker;
261
- Dict: StructType<{
262
- key: import("./types.js").RecursiveTypeMarker;
263
- value: import("./types.js").RecursiveTypeMarker;
250
+ readonly type: RecursiveType<VariantType<{
251
+ readonly Never: import("./types.js").NullType;
252
+ readonly Null: import("./types.js").NullType;
253
+ readonly Boolean: import("./types.js").NullType;
254
+ readonly Integer: import("./types.js").NullType;
255
+ readonly Float: import("./types.js").NullType;
256
+ readonly String: import("./types.js").NullType;
257
+ readonly DateTime: import("./types.js").NullType;
258
+ readonly Blob: import("./types.js").NullType;
259
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
260
+ readonly Array: import("./types.js").RecursiveTypeMarker;
261
+ readonly Set: import("./types.js").RecursiveTypeMarker;
262
+ readonly Dict: StructType<{
263
+ readonly key: import("./types.js").RecursiveTypeMarker;
264
+ readonly value: import("./types.js").RecursiveTypeMarker;
264
265
  }>;
265
- Struct: ArrayType<StructType<{
266
- name: StringType;
267
- type: import("./types.js").RecursiveTypeMarker;
266
+ readonly Struct: ArrayType<StructType<{
267
+ readonly name: StringType;
268
+ readonly type: import("./types.js").RecursiveTypeMarker;
268
269
  }>>;
269
- Variant: ArrayType<StructType<{
270
- name: StringType;
271
- type: import("./types.js").RecursiveTypeMarker;
270
+ readonly Variant: ArrayType<StructType<{
271
+ readonly name: StringType;
272
+ readonly type: import("./types.js").RecursiveTypeMarker;
272
273
  }>>;
273
- Recursive: IntegerType;
274
- Function: StructType<{
275
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
276
- output: import("./types.js").RecursiveTypeMarker;
274
+ readonly Recursive: IntegerType;
275
+ readonly Function: StructType<{
276
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
277
+ readonly output: import("./types.js").RecursiveTypeMarker;
277
278
  }>;
278
- AsyncFunction: StructType<{
279
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
280
- output: import("./types.js").RecursiveTypeMarker;
279
+ readonly AsyncFunction: StructType<{
280
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
281
+ readonly output: import("./types.js").RecursiveTypeMarker;
281
282
  }>;
282
283
  }>>;
283
- location: StructType<{
284
- filename: StringType;
285
- line: IntegerType;
286
- column: IntegerType;
284
+ readonly location: StructType<{
285
+ readonly filename: StringType;
286
+ readonly line: IntegerType;
287
+ readonly column: IntegerType;
287
288
  }>;
288
- name: StringType;
289
- mutable: BooleanType;
290
- captured: BooleanType;
289
+ readonly name: StringType;
290
+ readonly mutable: BooleanType;
291
+ readonly captured: BooleanType;
291
292
  }>;
292
293
  export declare const IRType: RecursiveType<VariantType<{
293
- Error: StructType<{
294
- type: RecursiveType<VariantType<{
295
- Never: import("./types.js").NullType;
296
- Null: import("./types.js").NullType;
297
- Boolean: import("./types.js").NullType;
298
- Integer: import("./types.js").NullType;
299
- Float: import("./types.js").NullType;
300
- String: import("./types.js").NullType;
301
- DateTime: import("./types.js").NullType;
302
- Blob: import("./types.js").NullType;
303
- Ref: import("./types.js").RecursiveTypeMarker;
304
- Array: import("./types.js").RecursiveTypeMarker;
305
- Set: import("./types.js").RecursiveTypeMarker;
306
- Dict: StructType<{
307
- key: import("./types.js").RecursiveTypeMarker;
308
- value: import("./types.js").RecursiveTypeMarker;
309
- }>;
310
- Struct: ArrayType<StructType<{
311
- name: StringType;
312
- type: import("./types.js").RecursiveTypeMarker;
313
- }>>;
314
- Variant: ArrayType<StructType<{
315
- name: StringType;
316
- type: import("./types.js").RecursiveTypeMarker;
317
- }>>;
318
- Recursive: IntegerType;
319
- Function: StructType<{
320
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
321
- output: import("./types.js").RecursiveTypeMarker;
322
- }>;
323
- AsyncFunction: StructType<{
324
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
325
- output: import("./types.js").RecursiveTypeMarker;
294
+ readonly Error: StructType<{
295
+ readonly type: RecursiveType<VariantType<{
296
+ readonly Never: import("./types.js").NullType;
297
+ readonly Null: import("./types.js").NullType;
298
+ readonly Boolean: import("./types.js").NullType;
299
+ readonly Integer: import("./types.js").NullType;
300
+ readonly Float: import("./types.js").NullType;
301
+ readonly String: import("./types.js").NullType;
302
+ readonly DateTime: import("./types.js").NullType;
303
+ readonly Blob: import("./types.js").NullType;
304
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
305
+ readonly Array: import("./types.js").RecursiveTypeMarker;
306
+ readonly Set: import("./types.js").RecursiveTypeMarker;
307
+ readonly Dict: StructType<{
308
+ readonly key: import("./types.js").RecursiveTypeMarker;
309
+ readonly value: import("./types.js").RecursiveTypeMarker;
310
+ }>;
311
+ readonly Struct: ArrayType<StructType<{
312
+ readonly name: StringType;
313
+ readonly type: import("./types.js").RecursiveTypeMarker;
314
+ }>>;
315
+ readonly Variant: ArrayType<StructType<{
316
+ readonly name: StringType;
317
+ readonly type: import("./types.js").RecursiveTypeMarker;
318
+ }>>;
319
+ readonly Recursive: IntegerType;
320
+ readonly Function: StructType<{
321
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
322
+ readonly output: import("./types.js").RecursiveTypeMarker;
323
+ }>;
324
+ readonly AsyncFunction: StructType<{
325
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
326
+ readonly output: import("./types.js").RecursiveTypeMarker;
326
327
  }>;
327
328
  }>>;
328
- location: StructType<{
329
- filename: StringType;
330
- line: IntegerType;
331
- column: IntegerType;
329
+ readonly location: StructType<{
330
+ readonly filename: StringType;
331
+ readonly line: IntegerType;
332
+ readonly column: IntegerType;
332
333
  }>;
333
- message: import("./types.js").RecursiveTypeMarker;
334
+ readonly message: import("./types.js").RecursiveTypeMarker;
334
335
  }>;
335
- TryCatch: StructType<{
336
- type: RecursiveType<VariantType<{
337
- Never: import("./types.js").NullType;
338
- Null: import("./types.js").NullType;
339
- Boolean: import("./types.js").NullType;
340
- Integer: import("./types.js").NullType;
341
- Float: import("./types.js").NullType;
342
- String: import("./types.js").NullType;
343
- DateTime: import("./types.js").NullType;
344
- Blob: import("./types.js").NullType;
345
- Ref: import("./types.js").RecursiveTypeMarker;
346
- Array: import("./types.js").RecursiveTypeMarker;
347
- Set: import("./types.js").RecursiveTypeMarker;
348
- Dict: StructType<{
349
- key: import("./types.js").RecursiveTypeMarker;
350
- value: import("./types.js").RecursiveTypeMarker;
351
- }>;
352
- Struct: ArrayType<StructType<{
353
- name: StringType;
354
- type: import("./types.js").RecursiveTypeMarker;
355
- }>>;
356
- Variant: ArrayType<StructType<{
357
- name: StringType;
358
- type: import("./types.js").RecursiveTypeMarker;
359
- }>>;
360
- Recursive: IntegerType;
361
- Function: StructType<{
362
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
363
- output: import("./types.js").RecursiveTypeMarker;
364
- }>;
365
- AsyncFunction: StructType<{
366
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
367
- output: import("./types.js").RecursiveTypeMarker;
336
+ readonly TryCatch: StructType<{
337
+ readonly type: RecursiveType<VariantType<{
338
+ readonly Never: import("./types.js").NullType;
339
+ readonly Null: import("./types.js").NullType;
340
+ readonly Boolean: import("./types.js").NullType;
341
+ readonly Integer: import("./types.js").NullType;
342
+ readonly Float: import("./types.js").NullType;
343
+ readonly String: import("./types.js").NullType;
344
+ readonly DateTime: import("./types.js").NullType;
345
+ readonly Blob: import("./types.js").NullType;
346
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
347
+ readonly Array: import("./types.js").RecursiveTypeMarker;
348
+ readonly Set: import("./types.js").RecursiveTypeMarker;
349
+ readonly Dict: StructType<{
350
+ readonly key: import("./types.js").RecursiveTypeMarker;
351
+ readonly value: import("./types.js").RecursiveTypeMarker;
352
+ }>;
353
+ readonly Struct: ArrayType<StructType<{
354
+ readonly name: StringType;
355
+ readonly type: import("./types.js").RecursiveTypeMarker;
356
+ }>>;
357
+ readonly Variant: ArrayType<StructType<{
358
+ readonly name: StringType;
359
+ readonly type: import("./types.js").RecursiveTypeMarker;
360
+ }>>;
361
+ readonly Recursive: IntegerType;
362
+ readonly Function: StructType<{
363
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
364
+ readonly output: import("./types.js").RecursiveTypeMarker;
365
+ }>;
366
+ readonly AsyncFunction: StructType<{
367
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
368
+ readonly output: import("./types.js").RecursiveTypeMarker;
368
369
  }>;
369
370
  }>>;
370
- location: StructType<{
371
- filename: StringType;
372
- line: IntegerType;
373
- column: IntegerType;
371
+ readonly location: StructType<{
372
+ readonly filename: StringType;
373
+ readonly line: IntegerType;
374
+ readonly column: IntegerType;
374
375
  }>;
375
- try_body: import("./types.js").RecursiveTypeMarker;
376
- catch_body: import("./types.js").RecursiveTypeMarker;
377
- message: import("./types.js").RecursiveTypeMarker;
378
- stack: import("./types.js").RecursiveTypeMarker;
379
- finally_body: import("./types.js").RecursiveTypeMarker;
376
+ readonly try_body: import("./types.js").RecursiveTypeMarker;
377
+ readonly catch_body: import("./types.js").RecursiveTypeMarker;
378
+ readonly message: import("./types.js").RecursiveTypeMarker;
379
+ readonly stack: import("./types.js").RecursiveTypeMarker;
380
+ readonly finally_body: import("./types.js").RecursiveTypeMarker;
380
381
  }>;
381
- Value: StructType<{
382
- type: RecursiveType<VariantType<{
383
- Never: import("./types.js").NullType;
384
- Null: import("./types.js").NullType;
385
- Boolean: import("./types.js").NullType;
386
- Integer: import("./types.js").NullType;
387
- Float: import("./types.js").NullType;
388
- String: import("./types.js").NullType;
389
- DateTime: import("./types.js").NullType;
390
- Blob: import("./types.js").NullType;
391
- Ref: import("./types.js").RecursiveTypeMarker;
392
- Array: import("./types.js").RecursiveTypeMarker;
393
- Set: import("./types.js").RecursiveTypeMarker;
394
- Dict: StructType<{
395
- key: import("./types.js").RecursiveTypeMarker;
396
- value: import("./types.js").RecursiveTypeMarker;
397
- }>;
398
- Struct: ArrayType<StructType<{
399
- name: StringType;
400
- type: import("./types.js").RecursiveTypeMarker;
401
- }>>;
402
- Variant: ArrayType<StructType<{
403
- name: StringType;
404
- type: import("./types.js").RecursiveTypeMarker;
405
- }>>;
406
- Recursive: IntegerType;
407
- Function: StructType<{
408
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
409
- output: import("./types.js").RecursiveTypeMarker;
410
- }>;
411
- AsyncFunction: StructType<{
412
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
413
- output: import("./types.js").RecursiveTypeMarker;
382
+ readonly Value: StructType<{
383
+ readonly type: RecursiveType<VariantType<{
384
+ readonly Never: import("./types.js").NullType;
385
+ readonly Null: import("./types.js").NullType;
386
+ readonly Boolean: import("./types.js").NullType;
387
+ readonly Integer: import("./types.js").NullType;
388
+ readonly Float: import("./types.js").NullType;
389
+ readonly String: import("./types.js").NullType;
390
+ readonly DateTime: import("./types.js").NullType;
391
+ readonly Blob: import("./types.js").NullType;
392
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
393
+ readonly Array: import("./types.js").RecursiveTypeMarker;
394
+ readonly Set: import("./types.js").RecursiveTypeMarker;
395
+ readonly Dict: StructType<{
396
+ readonly key: import("./types.js").RecursiveTypeMarker;
397
+ readonly value: import("./types.js").RecursiveTypeMarker;
398
+ }>;
399
+ readonly Struct: ArrayType<StructType<{
400
+ readonly name: StringType;
401
+ readonly type: import("./types.js").RecursiveTypeMarker;
402
+ }>>;
403
+ readonly Variant: ArrayType<StructType<{
404
+ readonly name: StringType;
405
+ readonly type: import("./types.js").RecursiveTypeMarker;
406
+ }>>;
407
+ readonly Recursive: IntegerType;
408
+ readonly Function: StructType<{
409
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
410
+ readonly output: import("./types.js").RecursiveTypeMarker;
411
+ }>;
412
+ readonly AsyncFunction: StructType<{
413
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
414
+ readonly output: import("./types.js").RecursiveTypeMarker;
414
415
  }>;
415
416
  }>>;
416
- location: StructType<{
417
- filename: StringType;
418
- line: IntegerType;
419
- column: IntegerType;
417
+ readonly location: StructType<{
418
+ readonly filename: StringType;
419
+ readonly line: IntegerType;
420
+ readonly column: IntegerType;
420
421
  }>;
421
- value: VariantType<{
422
- Null: import("./types.js").NullType;
423
- Boolean: BooleanType;
424
- Integer: IntegerType;
425
- Float: import("./types.js").FloatType;
426
- String: StringType;
427
- DateTime: import("./types.js").DateTimeType;
428
- Blob: import("./types.js").BlobType;
422
+ readonly value: VariantType<{
423
+ readonly Null: import("./types.js").NullType;
424
+ readonly Boolean: BooleanType;
425
+ readonly Integer: IntegerType;
426
+ readonly Float: import("./types.js").FloatType;
427
+ readonly String: StringType;
428
+ readonly DateTime: import("./types.js").DateTimeType;
429
+ readonly Blob: import("./types.js").BlobType;
429
430
  }>;
430
431
  }>;
431
- Variable: StructType<{
432
- type: RecursiveType<VariantType<{
433
- Never: import("./types.js").NullType;
434
- Null: import("./types.js").NullType;
435
- Boolean: import("./types.js").NullType;
436
- Integer: import("./types.js").NullType;
437
- Float: import("./types.js").NullType;
438
- String: import("./types.js").NullType;
439
- DateTime: import("./types.js").NullType;
440
- Blob: import("./types.js").NullType;
441
- Ref: import("./types.js").RecursiveTypeMarker;
442
- Array: import("./types.js").RecursiveTypeMarker;
443
- Set: import("./types.js").RecursiveTypeMarker;
444
- Dict: StructType<{
445
- key: import("./types.js").RecursiveTypeMarker;
446
- value: import("./types.js").RecursiveTypeMarker;
447
- }>;
448
- Struct: ArrayType<StructType<{
449
- name: StringType;
450
- type: import("./types.js").RecursiveTypeMarker;
451
- }>>;
452
- Variant: ArrayType<StructType<{
453
- name: StringType;
454
- type: import("./types.js").RecursiveTypeMarker;
455
- }>>;
456
- Recursive: IntegerType;
457
- Function: StructType<{
458
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
459
- output: import("./types.js").RecursiveTypeMarker;
460
- }>;
461
- AsyncFunction: StructType<{
462
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
463
- output: import("./types.js").RecursiveTypeMarker;
432
+ readonly Variable: StructType<{
433
+ readonly type: RecursiveType<VariantType<{
434
+ readonly Never: import("./types.js").NullType;
435
+ readonly Null: import("./types.js").NullType;
436
+ readonly Boolean: import("./types.js").NullType;
437
+ readonly Integer: import("./types.js").NullType;
438
+ readonly Float: import("./types.js").NullType;
439
+ readonly String: import("./types.js").NullType;
440
+ readonly DateTime: import("./types.js").NullType;
441
+ readonly Blob: import("./types.js").NullType;
442
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
443
+ readonly Array: import("./types.js").RecursiveTypeMarker;
444
+ readonly Set: import("./types.js").RecursiveTypeMarker;
445
+ readonly Dict: StructType<{
446
+ readonly key: import("./types.js").RecursiveTypeMarker;
447
+ readonly value: import("./types.js").RecursiveTypeMarker;
448
+ }>;
449
+ readonly Struct: ArrayType<StructType<{
450
+ readonly name: StringType;
451
+ readonly type: import("./types.js").RecursiveTypeMarker;
452
+ }>>;
453
+ readonly Variant: ArrayType<StructType<{
454
+ readonly name: StringType;
455
+ readonly type: import("./types.js").RecursiveTypeMarker;
456
+ }>>;
457
+ readonly Recursive: IntegerType;
458
+ readonly Function: StructType<{
459
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
460
+ readonly output: import("./types.js").RecursiveTypeMarker;
461
+ }>;
462
+ readonly AsyncFunction: StructType<{
463
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
464
+ readonly output: import("./types.js").RecursiveTypeMarker;
464
465
  }>;
465
466
  }>>;
466
- location: StructType<{
467
- filename: StringType;
468
- line: IntegerType;
469
- column: IntegerType;
467
+ readonly location: StructType<{
468
+ readonly filename: StringType;
469
+ readonly line: IntegerType;
470
+ readonly column: IntegerType;
470
471
  }>;
471
- name: StringType;
472
- mutable: BooleanType;
473
- captured: BooleanType;
472
+ readonly name: StringType;
473
+ readonly mutable: BooleanType;
474
+ readonly captured: BooleanType;
474
475
  }>;
475
- Let: StructType<{
476
- type: RecursiveType<VariantType<{
477
- Never: import("./types.js").NullType;
478
- Null: import("./types.js").NullType;
479
- Boolean: import("./types.js").NullType;
480
- Integer: import("./types.js").NullType;
481
- Float: import("./types.js").NullType;
482
- String: import("./types.js").NullType;
483
- DateTime: import("./types.js").NullType;
484
- Blob: import("./types.js").NullType;
485
- Ref: import("./types.js").RecursiveTypeMarker;
486
- Array: import("./types.js").RecursiveTypeMarker;
487
- Set: import("./types.js").RecursiveTypeMarker;
488
- Dict: StructType<{
489
- key: import("./types.js").RecursiveTypeMarker;
490
- value: import("./types.js").RecursiveTypeMarker;
491
- }>;
492
- Struct: ArrayType<StructType<{
493
- name: StringType;
494
- type: import("./types.js").RecursiveTypeMarker;
495
- }>>;
496
- Variant: ArrayType<StructType<{
497
- name: StringType;
498
- type: import("./types.js").RecursiveTypeMarker;
499
- }>>;
500
- Recursive: IntegerType;
501
- Function: StructType<{
502
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
503
- output: import("./types.js").RecursiveTypeMarker;
504
- }>;
505
- AsyncFunction: StructType<{
506
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
507
- output: import("./types.js").RecursiveTypeMarker;
476
+ readonly Let: StructType<{
477
+ readonly type: RecursiveType<VariantType<{
478
+ readonly Never: import("./types.js").NullType;
479
+ readonly Null: import("./types.js").NullType;
480
+ readonly Boolean: import("./types.js").NullType;
481
+ readonly Integer: import("./types.js").NullType;
482
+ readonly Float: import("./types.js").NullType;
483
+ readonly String: import("./types.js").NullType;
484
+ readonly DateTime: import("./types.js").NullType;
485
+ readonly Blob: import("./types.js").NullType;
486
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
487
+ readonly Array: import("./types.js").RecursiveTypeMarker;
488
+ readonly Set: import("./types.js").RecursiveTypeMarker;
489
+ readonly Dict: StructType<{
490
+ readonly key: import("./types.js").RecursiveTypeMarker;
491
+ readonly value: import("./types.js").RecursiveTypeMarker;
492
+ }>;
493
+ readonly Struct: ArrayType<StructType<{
494
+ readonly name: StringType;
495
+ readonly type: import("./types.js").RecursiveTypeMarker;
496
+ }>>;
497
+ readonly Variant: ArrayType<StructType<{
498
+ readonly name: StringType;
499
+ readonly type: import("./types.js").RecursiveTypeMarker;
500
+ }>>;
501
+ readonly Recursive: IntegerType;
502
+ readonly Function: StructType<{
503
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
504
+ readonly output: import("./types.js").RecursiveTypeMarker;
505
+ }>;
506
+ readonly AsyncFunction: StructType<{
507
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
508
+ readonly output: import("./types.js").RecursiveTypeMarker;
508
509
  }>;
509
510
  }>>;
510
- location: StructType<{
511
- filename: StringType;
512
- line: IntegerType;
513
- column: IntegerType;
511
+ readonly location: StructType<{
512
+ readonly filename: StringType;
513
+ readonly line: IntegerType;
514
+ readonly column: IntegerType;
514
515
  }>;
515
- variable: import("./types.js").RecursiveTypeMarker;
516
- value: import("./types.js").RecursiveTypeMarker;
516
+ readonly variable: import("./types.js").RecursiveTypeMarker;
517
+ readonly value: import("./types.js").RecursiveTypeMarker;
517
518
  }>;
518
- Assign: StructType<{
519
- type: RecursiveType<VariantType<{
520
- Never: import("./types.js").NullType;
521
- Null: import("./types.js").NullType;
522
- Boolean: import("./types.js").NullType;
523
- Integer: import("./types.js").NullType;
524
- Float: import("./types.js").NullType;
525
- String: import("./types.js").NullType;
526
- DateTime: import("./types.js").NullType;
527
- Blob: import("./types.js").NullType;
528
- Ref: import("./types.js").RecursiveTypeMarker;
529
- Array: import("./types.js").RecursiveTypeMarker;
530
- Set: import("./types.js").RecursiveTypeMarker;
531
- Dict: StructType<{
532
- key: import("./types.js").RecursiveTypeMarker;
533
- value: import("./types.js").RecursiveTypeMarker;
534
- }>;
535
- Struct: ArrayType<StructType<{
536
- name: StringType;
537
- type: import("./types.js").RecursiveTypeMarker;
538
- }>>;
539
- Variant: ArrayType<StructType<{
540
- name: StringType;
541
- type: import("./types.js").RecursiveTypeMarker;
542
- }>>;
543
- Recursive: IntegerType;
544
- Function: StructType<{
545
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
546
- output: import("./types.js").RecursiveTypeMarker;
547
- }>;
548
- AsyncFunction: StructType<{
549
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
550
- output: import("./types.js").RecursiveTypeMarker;
519
+ readonly Assign: StructType<{
520
+ readonly type: RecursiveType<VariantType<{
521
+ readonly Never: import("./types.js").NullType;
522
+ readonly Null: import("./types.js").NullType;
523
+ readonly Boolean: import("./types.js").NullType;
524
+ readonly Integer: import("./types.js").NullType;
525
+ readonly Float: import("./types.js").NullType;
526
+ readonly String: import("./types.js").NullType;
527
+ readonly DateTime: import("./types.js").NullType;
528
+ readonly Blob: import("./types.js").NullType;
529
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
530
+ readonly Array: import("./types.js").RecursiveTypeMarker;
531
+ readonly Set: import("./types.js").RecursiveTypeMarker;
532
+ readonly Dict: StructType<{
533
+ readonly key: import("./types.js").RecursiveTypeMarker;
534
+ readonly value: import("./types.js").RecursiveTypeMarker;
535
+ }>;
536
+ readonly Struct: ArrayType<StructType<{
537
+ readonly name: StringType;
538
+ readonly type: import("./types.js").RecursiveTypeMarker;
539
+ }>>;
540
+ readonly Variant: ArrayType<StructType<{
541
+ readonly name: StringType;
542
+ readonly type: import("./types.js").RecursiveTypeMarker;
543
+ }>>;
544
+ readonly Recursive: IntegerType;
545
+ readonly Function: StructType<{
546
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
547
+ readonly output: import("./types.js").RecursiveTypeMarker;
548
+ }>;
549
+ readonly AsyncFunction: StructType<{
550
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
551
+ readonly output: import("./types.js").RecursiveTypeMarker;
551
552
  }>;
552
553
  }>>;
553
- location: StructType<{
554
- filename: StringType;
555
- line: IntegerType;
556
- column: IntegerType;
554
+ readonly location: StructType<{
555
+ readonly filename: StringType;
556
+ readonly line: IntegerType;
557
+ readonly column: IntegerType;
557
558
  }>;
558
- variable: import("./types.js").RecursiveTypeMarker;
559
- value: import("./types.js").RecursiveTypeMarker;
559
+ readonly variable: import("./types.js").RecursiveTypeMarker;
560
+ readonly value: import("./types.js").RecursiveTypeMarker;
560
561
  }>;
561
- As: StructType<{
562
- type: RecursiveType<VariantType<{
563
- Never: import("./types.js").NullType;
564
- Null: import("./types.js").NullType;
565
- Boolean: import("./types.js").NullType;
566
- Integer: import("./types.js").NullType;
567
- Float: import("./types.js").NullType;
568
- String: import("./types.js").NullType;
569
- DateTime: import("./types.js").NullType;
570
- Blob: import("./types.js").NullType;
571
- Ref: import("./types.js").RecursiveTypeMarker;
572
- Array: import("./types.js").RecursiveTypeMarker;
573
- Set: import("./types.js").RecursiveTypeMarker;
574
- Dict: StructType<{
575
- key: import("./types.js").RecursiveTypeMarker;
576
- value: import("./types.js").RecursiveTypeMarker;
577
- }>;
578
- Struct: ArrayType<StructType<{
579
- name: StringType;
580
- type: import("./types.js").RecursiveTypeMarker;
581
- }>>;
582
- Variant: ArrayType<StructType<{
583
- name: StringType;
584
- type: import("./types.js").RecursiveTypeMarker;
585
- }>>;
586
- Recursive: IntegerType;
587
- Function: StructType<{
588
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
589
- output: import("./types.js").RecursiveTypeMarker;
590
- }>;
591
- AsyncFunction: StructType<{
592
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
593
- output: import("./types.js").RecursiveTypeMarker;
562
+ readonly As: StructType<{
563
+ readonly type: RecursiveType<VariantType<{
564
+ readonly Never: import("./types.js").NullType;
565
+ readonly Null: import("./types.js").NullType;
566
+ readonly Boolean: import("./types.js").NullType;
567
+ readonly Integer: import("./types.js").NullType;
568
+ readonly Float: import("./types.js").NullType;
569
+ readonly String: import("./types.js").NullType;
570
+ readonly DateTime: import("./types.js").NullType;
571
+ readonly Blob: import("./types.js").NullType;
572
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
573
+ readonly Array: import("./types.js").RecursiveTypeMarker;
574
+ readonly Set: import("./types.js").RecursiveTypeMarker;
575
+ readonly Dict: StructType<{
576
+ readonly key: import("./types.js").RecursiveTypeMarker;
577
+ readonly value: import("./types.js").RecursiveTypeMarker;
578
+ }>;
579
+ readonly Struct: ArrayType<StructType<{
580
+ readonly name: StringType;
581
+ readonly type: import("./types.js").RecursiveTypeMarker;
582
+ }>>;
583
+ readonly Variant: ArrayType<StructType<{
584
+ readonly name: StringType;
585
+ readonly type: import("./types.js").RecursiveTypeMarker;
586
+ }>>;
587
+ readonly Recursive: IntegerType;
588
+ readonly Function: StructType<{
589
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
590
+ readonly output: import("./types.js").RecursiveTypeMarker;
591
+ }>;
592
+ readonly AsyncFunction: StructType<{
593
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
594
+ readonly output: import("./types.js").RecursiveTypeMarker;
594
595
  }>;
595
596
  }>>;
596
- location: StructType<{
597
- filename: StringType;
598
- line: IntegerType;
599
- column: IntegerType;
597
+ readonly location: StructType<{
598
+ readonly filename: StringType;
599
+ readonly line: IntegerType;
600
+ readonly column: IntegerType;
600
601
  }>;
601
- value: import("./types.js").RecursiveTypeMarker;
602
+ readonly value: import("./types.js").RecursiveTypeMarker;
602
603
  }>;
603
- Function: StructType<{
604
- type: RecursiveType<VariantType<{
605
- Never: import("./types.js").NullType;
606
- Null: import("./types.js").NullType;
607
- Boolean: import("./types.js").NullType;
608
- Integer: import("./types.js").NullType;
609
- Float: import("./types.js").NullType;
610
- String: import("./types.js").NullType;
611
- DateTime: import("./types.js").NullType;
612
- Blob: import("./types.js").NullType;
613
- Ref: import("./types.js").RecursiveTypeMarker;
614
- Array: import("./types.js").RecursiveTypeMarker;
615
- Set: import("./types.js").RecursiveTypeMarker;
616
- Dict: StructType<{
617
- key: import("./types.js").RecursiveTypeMarker;
618
- value: import("./types.js").RecursiveTypeMarker;
619
- }>;
620
- Struct: ArrayType<StructType<{
621
- name: StringType;
622
- type: import("./types.js").RecursiveTypeMarker;
623
- }>>;
624
- Variant: ArrayType<StructType<{
625
- name: StringType;
626
- type: import("./types.js").RecursiveTypeMarker;
627
- }>>;
628
- Recursive: IntegerType;
629
- Function: StructType<{
630
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
631
- output: import("./types.js").RecursiveTypeMarker;
632
- }>;
633
- AsyncFunction: StructType<{
634
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
635
- output: import("./types.js").RecursiveTypeMarker;
604
+ readonly Function: StructType<{
605
+ readonly type: RecursiveType<VariantType<{
606
+ readonly Never: import("./types.js").NullType;
607
+ readonly Null: import("./types.js").NullType;
608
+ readonly Boolean: import("./types.js").NullType;
609
+ readonly Integer: import("./types.js").NullType;
610
+ readonly Float: import("./types.js").NullType;
611
+ readonly String: import("./types.js").NullType;
612
+ readonly DateTime: import("./types.js").NullType;
613
+ readonly Blob: import("./types.js").NullType;
614
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
615
+ readonly Array: import("./types.js").RecursiveTypeMarker;
616
+ readonly Set: import("./types.js").RecursiveTypeMarker;
617
+ readonly Dict: StructType<{
618
+ readonly key: import("./types.js").RecursiveTypeMarker;
619
+ readonly value: import("./types.js").RecursiveTypeMarker;
620
+ }>;
621
+ readonly Struct: ArrayType<StructType<{
622
+ readonly name: StringType;
623
+ readonly type: import("./types.js").RecursiveTypeMarker;
624
+ }>>;
625
+ readonly Variant: ArrayType<StructType<{
626
+ readonly name: StringType;
627
+ readonly type: import("./types.js").RecursiveTypeMarker;
628
+ }>>;
629
+ readonly Recursive: IntegerType;
630
+ readonly Function: StructType<{
631
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
632
+ readonly output: import("./types.js").RecursiveTypeMarker;
633
+ }>;
634
+ readonly AsyncFunction: StructType<{
635
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
636
+ readonly output: import("./types.js").RecursiveTypeMarker;
636
637
  }>;
637
638
  }>>;
638
- location: StructType<{
639
- filename: StringType;
640
- line: IntegerType;
641
- column: IntegerType;
639
+ readonly location: StructType<{
640
+ readonly filename: StringType;
641
+ readonly line: IntegerType;
642
+ readonly column: IntegerType;
642
643
  }>;
643
- captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
644
- parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
645
- body: import("./types.js").RecursiveTypeMarker;
644
+ readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
645
+ readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
646
+ readonly body: import("./types.js").RecursiveTypeMarker;
646
647
  }>;
647
- AsyncFunction: StructType<{
648
- type: RecursiveType<VariantType<{
649
- Never: import("./types.js").NullType;
650
- Null: import("./types.js").NullType;
651
- Boolean: import("./types.js").NullType;
652
- Integer: import("./types.js").NullType;
653
- Float: import("./types.js").NullType;
654
- String: import("./types.js").NullType;
655
- DateTime: import("./types.js").NullType;
656
- Blob: import("./types.js").NullType;
657
- Ref: import("./types.js").RecursiveTypeMarker;
658
- Array: import("./types.js").RecursiveTypeMarker;
659
- Set: import("./types.js").RecursiveTypeMarker;
660
- Dict: StructType<{
661
- key: import("./types.js").RecursiveTypeMarker;
662
- value: import("./types.js").RecursiveTypeMarker;
663
- }>;
664
- Struct: ArrayType<StructType<{
665
- name: StringType;
666
- type: import("./types.js").RecursiveTypeMarker;
667
- }>>;
668
- Variant: ArrayType<StructType<{
669
- name: StringType;
670
- type: import("./types.js").RecursiveTypeMarker;
671
- }>>;
672
- Recursive: IntegerType;
673
- Function: StructType<{
674
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
675
- output: import("./types.js").RecursiveTypeMarker;
676
- }>;
677
- AsyncFunction: StructType<{
678
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
679
- output: import("./types.js").RecursiveTypeMarker;
648
+ readonly AsyncFunction: StructType<{
649
+ readonly type: RecursiveType<VariantType<{
650
+ readonly Never: import("./types.js").NullType;
651
+ readonly Null: import("./types.js").NullType;
652
+ readonly Boolean: import("./types.js").NullType;
653
+ readonly Integer: import("./types.js").NullType;
654
+ readonly Float: import("./types.js").NullType;
655
+ readonly String: import("./types.js").NullType;
656
+ readonly DateTime: import("./types.js").NullType;
657
+ readonly Blob: import("./types.js").NullType;
658
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
659
+ readonly Array: import("./types.js").RecursiveTypeMarker;
660
+ readonly Set: import("./types.js").RecursiveTypeMarker;
661
+ readonly Dict: StructType<{
662
+ readonly key: import("./types.js").RecursiveTypeMarker;
663
+ readonly value: import("./types.js").RecursiveTypeMarker;
664
+ }>;
665
+ readonly Struct: ArrayType<StructType<{
666
+ readonly name: StringType;
667
+ readonly type: import("./types.js").RecursiveTypeMarker;
668
+ }>>;
669
+ readonly Variant: ArrayType<StructType<{
670
+ readonly name: StringType;
671
+ readonly type: import("./types.js").RecursiveTypeMarker;
672
+ }>>;
673
+ readonly Recursive: IntegerType;
674
+ readonly Function: StructType<{
675
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
676
+ readonly output: import("./types.js").RecursiveTypeMarker;
677
+ }>;
678
+ readonly AsyncFunction: StructType<{
679
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
680
+ readonly output: import("./types.js").RecursiveTypeMarker;
680
681
  }>;
681
682
  }>>;
682
- location: StructType<{
683
- filename: StringType;
684
- line: IntegerType;
685
- column: IntegerType;
683
+ readonly location: StructType<{
684
+ readonly filename: StringType;
685
+ readonly line: IntegerType;
686
+ readonly column: IntegerType;
686
687
  }>;
687
- captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
688
- parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
689
- body: import("./types.js").RecursiveTypeMarker;
688
+ readonly captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
689
+ readonly parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
690
+ readonly body: import("./types.js").RecursiveTypeMarker;
690
691
  }>;
691
- Call: StructType<{
692
- type: RecursiveType<VariantType<{
693
- Never: import("./types.js").NullType;
694
- Null: import("./types.js").NullType;
695
- Boolean: import("./types.js").NullType;
696
- Integer: import("./types.js").NullType;
697
- Float: import("./types.js").NullType;
698
- String: import("./types.js").NullType;
699
- DateTime: import("./types.js").NullType;
700
- Blob: import("./types.js").NullType;
701
- Ref: import("./types.js").RecursiveTypeMarker;
702
- Array: import("./types.js").RecursiveTypeMarker;
703
- Set: import("./types.js").RecursiveTypeMarker;
704
- Dict: StructType<{
705
- key: import("./types.js").RecursiveTypeMarker;
706
- value: import("./types.js").RecursiveTypeMarker;
707
- }>;
708
- Struct: ArrayType<StructType<{
709
- name: StringType;
710
- type: import("./types.js").RecursiveTypeMarker;
711
- }>>;
712
- Variant: ArrayType<StructType<{
713
- name: StringType;
714
- type: import("./types.js").RecursiveTypeMarker;
715
- }>>;
716
- Recursive: IntegerType;
717
- Function: StructType<{
718
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
719
- output: import("./types.js").RecursiveTypeMarker;
720
- }>;
721
- AsyncFunction: StructType<{
722
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
723
- output: import("./types.js").RecursiveTypeMarker;
692
+ readonly Call: StructType<{
693
+ readonly type: RecursiveType<VariantType<{
694
+ readonly Never: import("./types.js").NullType;
695
+ readonly Null: import("./types.js").NullType;
696
+ readonly Boolean: import("./types.js").NullType;
697
+ readonly Integer: import("./types.js").NullType;
698
+ readonly Float: import("./types.js").NullType;
699
+ readonly String: import("./types.js").NullType;
700
+ readonly DateTime: import("./types.js").NullType;
701
+ readonly Blob: import("./types.js").NullType;
702
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
703
+ readonly Array: import("./types.js").RecursiveTypeMarker;
704
+ readonly Set: import("./types.js").RecursiveTypeMarker;
705
+ readonly Dict: StructType<{
706
+ readonly key: import("./types.js").RecursiveTypeMarker;
707
+ readonly value: import("./types.js").RecursiveTypeMarker;
708
+ }>;
709
+ readonly Struct: ArrayType<StructType<{
710
+ readonly name: StringType;
711
+ readonly type: import("./types.js").RecursiveTypeMarker;
712
+ }>>;
713
+ readonly Variant: ArrayType<StructType<{
714
+ readonly name: StringType;
715
+ readonly type: import("./types.js").RecursiveTypeMarker;
716
+ }>>;
717
+ readonly Recursive: IntegerType;
718
+ readonly Function: StructType<{
719
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
720
+ readonly output: import("./types.js").RecursiveTypeMarker;
721
+ }>;
722
+ readonly AsyncFunction: StructType<{
723
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
724
+ readonly output: import("./types.js").RecursiveTypeMarker;
724
725
  }>;
725
726
  }>>;
726
- location: StructType<{
727
- filename: StringType;
728
- line: IntegerType;
729
- column: IntegerType;
727
+ readonly location: StructType<{
728
+ readonly filename: StringType;
729
+ readonly line: IntegerType;
730
+ readonly column: IntegerType;
730
731
  }>;
731
- function: import("./types.js").RecursiveTypeMarker;
732
- arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
732
+ readonly function: import("./types.js").RecursiveTypeMarker;
733
+ readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
733
734
  }>;
734
- CallAsync: StructType<{
735
- type: RecursiveType<VariantType<{
736
- Never: import("./types.js").NullType;
737
- Null: import("./types.js").NullType;
738
- Boolean: import("./types.js").NullType;
739
- Integer: import("./types.js").NullType;
740
- Float: import("./types.js").NullType;
741
- String: import("./types.js").NullType;
742
- DateTime: import("./types.js").NullType;
743
- Blob: import("./types.js").NullType;
744
- Ref: import("./types.js").RecursiveTypeMarker;
745
- Array: import("./types.js").RecursiveTypeMarker;
746
- Set: import("./types.js").RecursiveTypeMarker;
747
- Dict: StructType<{
748
- key: import("./types.js").RecursiveTypeMarker;
749
- value: import("./types.js").RecursiveTypeMarker;
750
- }>;
751
- Struct: ArrayType<StructType<{
752
- name: StringType;
753
- type: import("./types.js").RecursiveTypeMarker;
754
- }>>;
755
- Variant: ArrayType<StructType<{
756
- name: StringType;
757
- type: import("./types.js").RecursiveTypeMarker;
758
- }>>;
759
- Recursive: IntegerType;
760
- Function: StructType<{
761
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
762
- output: import("./types.js").RecursiveTypeMarker;
763
- }>;
764
- AsyncFunction: StructType<{
765
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
766
- output: import("./types.js").RecursiveTypeMarker;
735
+ readonly CallAsync: StructType<{
736
+ readonly type: RecursiveType<VariantType<{
737
+ readonly Never: import("./types.js").NullType;
738
+ readonly Null: import("./types.js").NullType;
739
+ readonly Boolean: import("./types.js").NullType;
740
+ readonly Integer: import("./types.js").NullType;
741
+ readonly Float: import("./types.js").NullType;
742
+ readonly String: import("./types.js").NullType;
743
+ readonly DateTime: import("./types.js").NullType;
744
+ readonly Blob: import("./types.js").NullType;
745
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
746
+ readonly Array: import("./types.js").RecursiveTypeMarker;
747
+ readonly Set: import("./types.js").RecursiveTypeMarker;
748
+ readonly Dict: StructType<{
749
+ readonly key: import("./types.js").RecursiveTypeMarker;
750
+ readonly value: import("./types.js").RecursiveTypeMarker;
751
+ }>;
752
+ readonly Struct: ArrayType<StructType<{
753
+ readonly name: StringType;
754
+ readonly type: import("./types.js").RecursiveTypeMarker;
755
+ }>>;
756
+ readonly Variant: ArrayType<StructType<{
757
+ readonly name: StringType;
758
+ readonly type: import("./types.js").RecursiveTypeMarker;
759
+ }>>;
760
+ readonly Recursive: IntegerType;
761
+ readonly Function: StructType<{
762
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
763
+ readonly output: import("./types.js").RecursiveTypeMarker;
764
+ }>;
765
+ readonly AsyncFunction: StructType<{
766
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
767
+ readonly output: import("./types.js").RecursiveTypeMarker;
767
768
  }>;
768
769
  }>>;
769
- location: StructType<{
770
- filename: StringType;
771
- line: IntegerType;
772
- column: IntegerType;
770
+ readonly location: StructType<{
771
+ readonly filename: StringType;
772
+ readonly line: IntegerType;
773
+ readonly column: IntegerType;
773
774
  }>;
774
- function: import("./types.js").RecursiveTypeMarker;
775
- arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
775
+ readonly function: import("./types.js").RecursiveTypeMarker;
776
+ readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
776
777
  }>;
777
- NewRef: StructType<{
778
- type: RecursiveType<VariantType<{
779
- Never: import("./types.js").NullType;
780
- Null: import("./types.js").NullType;
781
- Boolean: import("./types.js").NullType;
782
- Integer: import("./types.js").NullType;
783
- Float: import("./types.js").NullType;
784
- String: import("./types.js").NullType;
785
- DateTime: import("./types.js").NullType;
786
- Blob: import("./types.js").NullType;
787
- Ref: import("./types.js").RecursiveTypeMarker;
788
- Array: import("./types.js").RecursiveTypeMarker;
789
- Set: import("./types.js").RecursiveTypeMarker;
790
- Dict: StructType<{
791
- key: import("./types.js").RecursiveTypeMarker;
792
- value: import("./types.js").RecursiveTypeMarker;
793
- }>;
794
- Struct: ArrayType<StructType<{
795
- name: StringType;
796
- type: import("./types.js").RecursiveTypeMarker;
797
- }>>;
798
- Variant: ArrayType<StructType<{
799
- name: StringType;
800
- type: import("./types.js").RecursiveTypeMarker;
801
- }>>;
802
- Recursive: IntegerType;
803
- Function: StructType<{
804
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
805
- output: import("./types.js").RecursiveTypeMarker;
806
- }>;
807
- AsyncFunction: StructType<{
808
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
809
- output: import("./types.js").RecursiveTypeMarker;
778
+ readonly NewRef: StructType<{
779
+ readonly type: RecursiveType<VariantType<{
780
+ readonly Never: import("./types.js").NullType;
781
+ readonly Null: import("./types.js").NullType;
782
+ readonly Boolean: import("./types.js").NullType;
783
+ readonly Integer: import("./types.js").NullType;
784
+ readonly Float: import("./types.js").NullType;
785
+ readonly String: import("./types.js").NullType;
786
+ readonly DateTime: import("./types.js").NullType;
787
+ readonly Blob: import("./types.js").NullType;
788
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
789
+ readonly Array: import("./types.js").RecursiveTypeMarker;
790
+ readonly Set: import("./types.js").RecursiveTypeMarker;
791
+ readonly Dict: StructType<{
792
+ readonly key: import("./types.js").RecursiveTypeMarker;
793
+ readonly value: import("./types.js").RecursiveTypeMarker;
794
+ }>;
795
+ readonly Struct: ArrayType<StructType<{
796
+ readonly name: StringType;
797
+ readonly type: import("./types.js").RecursiveTypeMarker;
798
+ }>>;
799
+ readonly Variant: ArrayType<StructType<{
800
+ readonly name: StringType;
801
+ readonly type: import("./types.js").RecursiveTypeMarker;
802
+ }>>;
803
+ readonly Recursive: IntegerType;
804
+ readonly Function: StructType<{
805
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
806
+ readonly output: import("./types.js").RecursiveTypeMarker;
807
+ }>;
808
+ readonly AsyncFunction: StructType<{
809
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
810
+ readonly output: import("./types.js").RecursiveTypeMarker;
810
811
  }>;
811
812
  }>>;
812
- location: StructType<{
813
- filename: StringType;
814
- line: IntegerType;
815
- column: IntegerType;
813
+ readonly location: StructType<{
814
+ readonly filename: StringType;
815
+ readonly line: IntegerType;
816
+ readonly column: IntegerType;
816
817
  }>;
817
- value: import("./types.js").RecursiveTypeMarker;
818
+ readonly value: import("./types.js").RecursiveTypeMarker;
818
819
  }>;
819
- NewArray: StructType<{
820
- type: RecursiveType<VariantType<{
821
- Never: import("./types.js").NullType;
822
- Null: import("./types.js").NullType;
823
- Boolean: import("./types.js").NullType;
824
- Integer: import("./types.js").NullType;
825
- Float: import("./types.js").NullType;
826
- String: import("./types.js").NullType;
827
- DateTime: import("./types.js").NullType;
828
- Blob: import("./types.js").NullType;
829
- Ref: import("./types.js").RecursiveTypeMarker;
830
- Array: import("./types.js").RecursiveTypeMarker;
831
- Set: import("./types.js").RecursiveTypeMarker;
832
- Dict: StructType<{
833
- key: import("./types.js").RecursiveTypeMarker;
834
- value: import("./types.js").RecursiveTypeMarker;
835
- }>;
836
- Struct: ArrayType<StructType<{
837
- name: StringType;
838
- type: import("./types.js").RecursiveTypeMarker;
839
- }>>;
840
- Variant: ArrayType<StructType<{
841
- name: StringType;
842
- type: import("./types.js").RecursiveTypeMarker;
843
- }>>;
844
- Recursive: IntegerType;
845
- Function: StructType<{
846
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
847
- output: import("./types.js").RecursiveTypeMarker;
848
- }>;
849
- AsyncFunction: StructType<{
850
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
851
- output: import("./types.js").RecursiveTypeMarker;
820
+ readonly NewArray: StructType<{
821
+ readonly type: RecursiveType<VariantType<{
822
+ readonly Never: import("./types.js").NullType;
823
+ readonly Null: import("./types.js").NullType;
824
+ readonly Boolean: import("./types.js").NullType;
825
+ readonly Integer: import("./types.js").NullType;
826
+ readonly Float: import("./types.js").NullType;
827
+ readonly String: import("./types.js").NullType;
828
+ readonly DateTime: import("./types.js").NullType;
829
+ readonly Blob: import("./types.js").NullType;
830
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
831
+ readonly Array: import("./types.js").RecursiveTypeMarker;
832
+ readonly Set: import("./types.js").RecursiveTypeMarker;
833
+ readonly Dict: StructType<{
834
+ readonly key: import("./types.js").RecursiveTypeMarker;
835
+ readonly value: import("./types.js").RecursiveTypeMarker;
836
+ }>;
837
+ readonly Struct: ArrayType<StructType<{
838
+ readonly name: StringType;
839
+ readonly type: import("./types.js").RecursiveTypeMarker;
840
+ }>>;
841
+ readonly Variant: ArrayType<StructType<{
842
+ readonly name: StringType;
843
+ readonly type: import("./types.js").RecursiveTypeMarker;
844
+ }>>;
845
+ readonly Recursive: IntegerType;
846
+ readonly Function: StructType<{
847
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
848
+ readonly output: import("./types.js").RecursiveTypeMarker;
849
+ }>;
850
+ readonly AsyncFunction: StructType<{
851
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
852
+ readonly output: import("./types.js").RecursiveTypeMarker;
852
853
  }>;
853
854
  }>>;
854
- location: StructType<{
855
- filename: StringType;
856
- line: IntegerType;
857
- column: IntegerType;
855
+ readonly location: StructType<{
856
+ readonly filename: StringType;
857
+ readonly line: IntegerType;
858
+ readonly column: IntegerType;
858
859
  }>;
859
- values: ArrayType<import("./types.js").RecursiveTypeMarker>;
860
+ readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
860
861
  }>;
861
- NewSet: StructType<{
862
- type: RecursiveType<VariantType<{
863
- Never: import("./types.js").NullType;
864
- Null: import("./types.js").NullType;
865
- Boolean: import("./types.js").NullType;
866
- Integer: import("./types.js").NullType;
867
- Float: import("./types.js").NullType;
868
- String: import("./types.js").NullType;
869
- DateTime: import("./types.js").NullType;
870
- Blob: import("./types.js").NullType;
871
- Ref: import("./types.js").RecursiveTypeMarker;
872
- Array: import("./types.js").RecursiveTypeMarker;
873
- Set: import("./types.js").RecursiveTypeMarker;
874
- Dict: StructType<{
875
- key: import("./types.js").RecursiveTypeMarker;
876
- value: import("./types.js").RecursiveTypeMarker;
877
- }>;
878
- Struct: ArrayType<StructType<{
879
- name: StringType;
880
- type: import("./types.js").RecursiveTypeMarker;
881
- }>>;
882
- Variant: ArrayType<StructType<{
883
- name: StringType;
884
- type: import("./types.js").RecursiveTypeMarker;
885
- }>>;
886
- Recursive: IntegerType;
887
- Function: StructType<{
888
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
889
- output: import("./types.js").RecursiveTypeMarker;
890
- }>;
891
- AsyncFunction: StructType<{
892
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
893
- output: import("./types.js").RecursiveTypeMarker;
862
+ readonly NewSet: StructType<{
863
+ readonly type: RecursiveType<VariantType<{
864
+ readonly Never: import("./types.js").NullType;
865
+ readonly Null: import("./types.js").NullType;
866
+ readonly Boolean: import("./types.js").NullType;
867
+ readonly Integer: import("./types.js").NullType;
868
+ readonly Float: import("./types.js").NullType;
869
+ readonly String: import("./types.js").NullType;
870
+ readonly DateTime: import("./types.js").NullType;
871
+ readonly Blob: import("./types.js").NullType;
872
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
873
+ readonly Array: import("./types.js").RecursiveTypeMarker;
874
+ readonly Set: import("./types.js").RecursiveTypeMarker;
875
+ readonly Dict: StructType<{
876
+ readonly key: import("./types.js").RecursiveTypeMarker;
877
+ readonly value: import("./types.js").RecursiveTypeMarker;
878
+ }>;
879
+ readonly Struct: ArrayType<StructType<{
880
+ readonly name: StringType;
881
+ readonly type: import("./types.js").RecursiveTypeMarker;
882
+ }>>;
883
+ readonly Variant: ArrayType<StructType<{
884
+ readonly name: StringType;
885
+ readonly type: import("./types.js").RecursiveTypeMarker;
886
+ }>>;
887
+ readonly Recursive: IntegerType;
888
+ readonly Function: StructType<{
889
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
890
+ readonly output: import("./types.js").RecursiveTypeMarker;
891
+ }>;
892
+ readonly AsyncFunction: StructType<{
893
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
894
+ readonly output: import("./types.js").RecursiveTypeMarker;
894
895
  }>;
895
896
  }>>;
896
- location: StructType<{
897
- filename: StringType;
898
- line: IntegerType;
899
- column: IntegerType;
897
+ readonly location: StructType<{
898
+ readonly filename: StringType;
899
+ readonly line: IntegerType;
900
+ readonly column: IntegerType;
900
901
  }>;
901
- values: ArrayType<import("./types.js").RecursiveTypeMarker>;
902
+ readonly values: ArrayType<import("./types.js").RecursiveTypeMarker>;
902
903
  }>;
903
- NewDict: StructType<{
904
- type: RecursiveType<VariantType<{
905
- Never: import("./types.js").NullType;
906
- Null: import("./types.js").NullType;
907
- Boolean: import("./types.js").NullType;
908
- Integer: import("./types.js").NullType;
909
- Float: import("./types.js").NullType;
910
- String: import("./types.js").NullType;
911
- DateTime: import("./types.js").NullType;
912
- Blob: import("./types.js").NullType;
913
- Ref: import("./types.js").RecursiveTypeMarker;
914
- Array: import("./types.js").RecursiveTypeMarker;
915
- Set: import("./types.js").RecursiveTypeMarker;
916
- Dict: StructType<{
917
- key: import("./types.js").RecursiveTypeMarker;
918
- value: import("./types.js").RecursiveTypeMarker;
919
- }>;
920
- Struct: ArrayType<StructType<{
921
- name: StringType;
922
- type: import("./types.js").RecursiveTypeMarker;
923
- }>>;
924
- Variant: ArrayType<StructType<{
925
- name: StringType;
926
- type: import("./types.js").RecursiveTypeMarker;
927
- }>>;
928
- Recursive: IntegerType;
929
- Function: StructType<{
930
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
931
- output: import("./types.js").RecursiveTypeMarker;
932
- }>;
933
- AsyncFunction: StructType<{
934
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
935
- output: import("./types.js").RecursiveTypeMarker;
904
+ readonly NewDict: StructType<{
905
+ readonly type: RecursiveType<VariantType<{
906
+ readonly Never: import("./types.js").NullType;
907
+ readonly Null: import("./types.js").NullType;
908
+ readonly Boolean: import("./types.js").NullType;
909
+ readonly Integer: import("./types.js").NullType;
910
+ readonly Float: import("./types.js").NullType;
911
+ readonly String: import("./types.js").NullType;
912
+ readonly DateTime: import("./types.js").NullType;
913
+ readonly Blob: import("./types.js").NullType;
914
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
915
+ readonly Array: import("./types.js").RecursiveTypeMarker;
916
+ readonly Set: import("./types.js").RecursiveTypeMarker;
917
+ readonly Dict: StructType<{
918
+ readonly key: import("./types.js").RecursiveTypeMarker;
919
+ readonly value: import("./types.js").RecursiveTypeMarker;
920
+ }>;
921
+ readonly Struct: ArrayType<StructType<{
922
+ readonly name: StringType;
923
+ readonly type: import("./types.js").RecursiveTypeMarker;
924
+ }>>;
925
+ readonly Variant: ArrayType<StructType<{
926
+ readonly name: StringType;
927
+ readonly type: import("./types.js").RecursiveTypeMarker;
928
+ }>>;
929
+ readonly Recursive: IntegerType;
930
+ readonly Function: StructType<{
931
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
932
+ readonly output: import("./types.js").RecursiveTypeMarker;
933
+ }>;
934
+ readonly AsyncFunction: StructType<{
935
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
936
+ readonly output: import("./types.js").RecursiveTypeMarker;
936
937
  }>;
937
938
  }>>;
938
- location: StructType<{
939
- filename: StringType;
940
- line: IntegerType;
941
- column: IntegerType;
939
+ readonly location: StructType<{
940
+ readonly filename: StringType;
941
+ readonly line: IntegerType;
942
+ readonly column: IntegerType;
942
943
  }>;
943
- values: ArrayType<StructType<{
944
- key: import("./types.js").RecursiveTypeMarker;
945
- value: import("./types.js").RecursiveTypeMarker;
944
+ readonly values: ArrayType<StructType<{
945
+ readonly key: import("./types.js").RecursiveTypeMarker;
946
+ readonly value: import("./types.js").RecursiveTypeMarker;
946
947
  }>>;
947
948
  }>;
948
- Struct: StructType<{
949
- type: RecursiveType<VariantType<{
950
- Never: import("./types.js").NullType;
951
- Null: import("./types.js").NullType;
952
- Boolean: import("./types.js").NullType;
953
- Integer: import("./types.js").NullType;
954
- Float: import("./types.js").NullType;
955
- String: import("./types.js").NullType;
956
- DateTime: import("./types.js").NullType;
957
- Blob: import("./types.js").NullType;
958
- Ref: import("./types.js").RecursiveTypeMarker;
959
- Array: import("./types.js").RecursiveTypeMarker;
960
- Set: import("./types.js").RecursiveTypeMarker;
961
- Dict: StructType<{
962
- key: import("./types.js").RecursiveTypeMarker;
963
- value: import("./types.js").RecursiveTypeMarker;
964
- }>;
965
- Struct: ArrayType<StructType<{
966
- name: StringType;
967
- type: import("./types.js").RecursiveTypeMarker;
968
- }>>;
969
- Variant: ArrayType<StructType<{
970
- name: StringType;
971
- type: import("./types.js").RecursiveTypeMarker;
972
- }>>;
973
- Recursive: IntegerType;
974
- Function: StructType<{
975
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
976
- output: import("./types.js").RecursiveTypeMarker;
977
- }>;
978
- AsyncFunction: StructType<{
979
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
980
- output: import("./types.js").RecursiveTypeMarker;
949
+ readonly Struct: StructType<{
950
+ readonly type: RecursiveType<VariantType<{
951
+ readonly Never: import("./types.js").NullType;
952
+ readonly Null: import("./types.js").NullType;
953
+ readonly Boolean: import("./types.js").NullType;
954
+ readonly Integer: import("./types.js").NullType;
955
+ readonly Float: import("./types.js").NullType;
956
+ readonly String: import("./types.js").NullType;
957
+ readonly DateTime: import("./types.js").NullType;
958
+ readonly Blob: import("./types.js").NullType;
959
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
960
+ readonly Array: import("./types.js").RecursiveTypeMarker;
961
+ readonly Set: import("./types.js").RecursiveTypeMarker;
962
+ readonly Dict: StructType<{
963
+ readonly key: import("./types.js").RecursiveTypeMarker;
964
+ readonly value: import("./types.js").RecursiveTypeMarker;
965
+ }>;
966
+ readonly Struct: ArrayType<StructType<{
967
+ readonly name: StringType;
968
+ readonly type: import("./types.js").RecursiveTypeMarker;
969
+ }>>;
970
+ readonly Variant: ArrayType<StructType<{
971
+ readonly name: StringType;
972
+ readonly type: import("./types.js").RecursiveTypeMarker;
973
+ }>>;
974
+ readonly Recursive: IntegerType;
975
+ readonly Function: StructType<{
976
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
977
+ readonly output: import("./types.js").RecursiveTypeMarker;
978
+ }>;
979
+ readonly AsyncFunction: StructType<{
980
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
981
+ readonly output: import("./types.js").RecursiveTypeMarker;
981
982
  }>;
982
983
  }>>;
983
- location: StructType<{
984
- filename: StringType;
985
- line: IntegerType;
986
- column: IntegerType;
984
+ readonly location: StructType<{
985
+ readonly filename: StringType;
986
+ readonly line: IntegerType;
987
+ readonly column: IntegerType;
987
988
  }>;
988
- fields: ArrayType<StructType<{
989
- name: StringType;
990
- value: import("./types.js").RecursiveTypeMarker;
989
+ readonly fields: ArrayType<StructType<{
990
+ readonly name: StringType;
991
+ readonly value: import("./types.js").RecursiveTypeMarker;
991
992
  }>>;
992
993
  }>;
993
- GetField: StructType<{
994
- type: RecursiveType<VariantType<{
995
- Never: import("./types.js").NullType;
996
- Null: import("./types.js").NullType;
997
- Boolean: import("./types.js").NullType;
998
- Integer: import("./types.js").NullType;
999
- Float: import("./types.js").NullType;
1000
- String: import("./types.js").NullType;
1001
- DateTime: import("./types.js").NullType;
1002
- Blob: import("./types.js").NullType;
1003
- Ref: import("./types.js").RecursiveTypeMarker;
1004
- Array: import("./types.js").RecursiveTypeMarker;
1005
- Set: import("./types.js").RecursiveTypeMarker;
1006
- Dict: StructType<{
1007
- key: import("./types.js").RecursiveTypeMarker;
1008
- value: import("./types.js").RecursiveTypeMarker;
1009
- }>;
1010
- Struct: ArrayType<StructType<{
1011
- name: StringType;
1012
- type: import("./types.js").RecursiveTypeMarker;
1013
- }>>;
1014
- Variant: ArrayType<StructType<{
1015
- name: StringType;
1016
- type: import("./types.js").RecursiveTypeMarker;
1017
- }>>;
1018
- Recursive: IntegerType;
1019
- Function: StructType<{
1020
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1021
- output: import("./types.js").RecursiveTypeMarker;
1022
- }>;
1023
- AsyncFunction: StructType<{
1024
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1025
- output: import("./types.js").RecursiveTypeMarker;
994
+ readonly GetField: StructType<{
995
+ readonly type: RecursiveType<VariantType<{
996
+ readonly Never: import("./types.js").NullType;
997
+ readonly Null: import("./types.js").NullType;
998
+ readonly Boolean: import("./types.js").NullType;
999
+ readonly Integer: import("./types.js").NullType;
1000
+ readonly Float: import("./types.js").NullType;
1001
+ readonly String: import("./types.js").NullType;
1002
+ readonly DateTime: import("./types.js").NullType;
1003
+ readonly Blob: import("./types.js").NullType;
1004
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1005
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1006
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1007
+ readonly Dict: StructType<{
1008
+ readonly key: import("./types.js").RecursiveTypeMarker;
1009
+ readonly value: import("./types.js").RecursiveTypeMarker;
1010
+ }>;
1011
+ readonly Struct: ArrayType<StructType<{
1012
+ readonly name: StringType;
1013
+ readonly type: import("./types.js").RecursiveTypeMarker;
1014
+ }>>;
1015
+ readonly Variant: ArrayType<StructType<{
1016
+ readonly name: StringType;
1017
+ readonly type: import("./types.js").RecursiveTypeMarker;
1018
+ }>>;
1019
+ readonly Recursive: IntegerType;
1020
+ readonly Function: StructType<{
1021
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1022
+ readonly output: import("./types.js").RecursiveTypeMarker;
1023
+ }>;
1024
+ readonly AsyncFunction: StructType<{
1025
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1026
+ readonly output: import("./types.js").RecursiveTypeMarker;
1026
1027
  }>;
1027
1028
  }>>;
1028
- location: StructType<{
1029
- filename: StringType;
1030
- line: IntegerType;
1031
- column: IntegerType;
1029
+ readonly location: StructType<{
1030
+ readonly filename: StringType;
1031
+ readonly line: IntegerType;
1032
+ readonly column: IntegerType;
1032
1033
  }>;
1033
- field: StringType;
1034
- struct: import("./types.js").RecursiveTypeMarker;
1034
+ readonly field: StringType;
1035
+ readonly struct: import("./types.js").RecursiveTypeMarker;
1035
1036
  }>;
1036
- Variant: StructType<{
1037
- type: RecursiveType<VariantType<{
1038
- Never: import("./types.js").NullType;
1039
- Null: import("./types.js").NullType;
1040
- Boolean: import("./types.js").NullType;
1041
- Integer: import("./types.js").NullType;
1042
- Float: import("./types.js").NullType;
1043
- String: import("./types.js").NullType;
1044
- DateTime: import("./types.js").NullType;
1045
- Blob: import("./types.js").NullType;
1046
- Ref: import("./types.js").RecursiveTypeMarker;
1047
- Array: import("./types.js").RecursiveTypeMarker;
1048
- Set: import("./types.js").RecursiveTypeMarker;
1049
- Dict: StructType<{
1050
- key: import("./types.js").RecursiveTypeMarker;
1051
- value: import("./types.js").RecursiveTypeMarker;
1052
- }>;
1053
- Struct: ArrayType<StructType<{
1054
- name: StringType;
1055
- type: import("./types.js").RecursiveTypeMarker;
1056
- }>>;
1057
- Variant: ArrayType<StructType<{
1058
- name: StringType;
1059
- type: import("./types.js").RecursiveTypeMarker;
1060
- }>>;
1061
- Recursive: IntegerType;
1062
- Function: StructType<{
1063
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1064
- output: import("./types.js").RecursiveTypeMarker;
1065
- }>;
1066
- AsyncFunction: StructType<{
1067
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1068
- output: import("./types.js").RecursiveTypeMarker;
1037
+ readonly Variant: StructType<{
1038
+ readonly type: RecursiveType<VariantType<{
1039
+ readonly Never: import("./types.js").NullType;
1040
+ readonly Null: import("./types.js").NullType;
1041
+ readonly Boolean: import("./types.js").NullType;
1042
+ readonly Integer: import("./types.js").NullType;
1043
+ readonly Float: import("./types.js").NullType;
1044
+ readonly String: import("./types.js").NullType;
1045
+ readonly DateTime: import("./types.js").NullType;
1046
+ readonly Blob: import("./types.js").NullType;
1047
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1048
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1049
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1050
+ readonly Dict: StructType<{
1051
+ readonly key: import("./types.js").RecursiveTypeMarker;
1052
+ readonly value: import("./types.js").RecursiveTypeMarker;
1053
+ }>;
1054
+ readonly Struct: ArrayType<StructType<{
1055
+ readonly name: StringType;
1056
+ readonly type: import("./types.js").RecursiveTypeMarker;
1057
+ }>>;
1058
+ readonly Variant: ArrayType<StructType<{
1059
+ readonly name: StringType;
1060
+ readonly type: import("./types.js").RecursiveTypeMarker;
1061
+ }>>;
1062
+ readonly Recursive: IntegerType;
1063
+ readonly Function: StructType<{
1064
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1065
+ readonly output: import("./types.js").RecursiveTypeMarker;
1066
+ }>;
1067
+ readonly AsyncFunction: StructType<{
1068
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1069
+ readonly output: import("./types.js").RecursiveTypeMarker;
1069
1070
  }>;
1070
1071
  }>>;
1071
- location: StructType<{
1072
- filename: StringType;
1073
- line: IntegerType;
1074
- column: IntegerType;
1072
+ readonly location: StructType<{
1073
+ readonly filename: StringType;
1074
+ readonly line: IntegerType;
1075
+ readonly column: IntegerType;
1075
1076
  }>;
1076
- case: StringType;
1077
- value: import("./types.js").RecursiveTypeMarker;
1077
+ readonly case: StringType;
1078
+ readonly value: import("./types.js").RecursiveTypeMarker;
1078
1079
  }>;
1079
- Block: StructType<{
1080
- type: RecursiveType<VariantType<{
1081
- Never: import("./types.js").NullType;
1082
- Null: import("./types.js").NullType;
1083
- Boolean: import("./types.js").NullType;
1084
- Integer: import("./types.js").NullType;
1085
- Float: import("./types.js").NullType;
1086
- String: import("./types.js").NullType;
1087
- DateTime: import("./types.js").NullType;
1088
- Blob: import("./types.js").NullType;
1089
- Ref: import("./types.js").RecursiveTypeMarker;
1090
- Array: import("./types.js").RecursiveTypeMarker;
1091
- Set: import("./types.js").RecursiveTypeMarker;
1092
- Dict: StructType<{
1093
- key: import("./types.js").RecursiveTypeMarker;
1094
- value: import("./types.js").RecursiveTypeMarker;
1095
- }>;
1096
- Struct: ArrayType<StructType<{
1097
- name: StringType;
1098
- type: import("./types.js").RecursiveTypeMarker;
1099
- }>>;
1100
- Variant: ArrayType<StructType<{
1101
- name: StringType;
1102
- type: import("./types.js").RecursiveTypeMarker;
1103
- }>>;
1104
- Recursive: IntegerType;
1105
- Function: StructType<{
1106
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1107
- output: import("./types.js").RecursiveTypeMarker;
1108
- }>;
1109
- AsyncFunction: StructType<{
1110
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1111
- output: import("./types.js").RecursiveTypeMarker;
1080
+ readonly Block: StructType<{
1081
+ readonly type: RecursiveType<VariantType<{
1082
+ readonly Never: import("./types.js").NullType;
1083
+ readonly Null: import("./types.js").NullType;
1084
+ readonly Boolean: import("./types.js").NullType;
1085
+ readonly Integer: import("./types.js").NullType;
1086
+ readonly Float: import("./types.js").NullType;
1087
+ readonly String: import("./types.js").NullType;
1088
+ readonly DateTime: import("./types.js").NullType;
1089
+ readonly Blob: import("./types.js").NullType;
1090
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1091
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1092
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1093
+ readonly Dict: StructType<{
1094
+ readonly key: import("./types.js").RecursiveTypeMarker;
1095
+ readonly value: import("./types.js").RecursiveTypeMarker;
1096
+ }>;
1097
+ readonly Struct: ArrayType<StructType<{
1098
+ readonly name: StringType;
1099
+ readonly type: import("./types.js").RecursiveTypeMarker;
1100
+ }>>;
1101
+ readonly Variant: ArrayType<StructType<{
1102
+ readonly name: StringType;
1103
+ readonly type: import("./types.js").RecursiveTypeMarker;
1104
+ }>>;
1105
+ readonly Recursive: IntegerType;
1106
+ readonly Function: StructType<{
1107
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1108
+ readonly output: import("./types.js").RecursiveTypeMarker;
1109
+ }>;
1110
+ readonly AsyncFunction: StructType<{
1111
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1112
+ readonly output: import("./types.js").RecursiveTypeMarker;
1112
1113
  }>;
1113
1114
  }>>;
1114
- location: StructType<{
1115
- filename: StringType;
1116
- line: IntegerType;
1117
- column: IntegerType;
1115
+ readonly location: StructType<{
1116
+ readonly filename: StringType;
1117
+ readonly line: IntegerType;
1118
+ readonly column: IntegerType;
1118
1119
  }>;
1119
- statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
1120
+ readonly statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
1120
1121
  }>;
1121
- IfElse: StructType<{
1122
- type: RecursiveType<VariantType<{
1123
- Never: import("./types.js").NullType;
1124
- Null: import("./types.js").NullType;
1125
- Boolean: import("./types.js").NullType;
1126
- Integer: import("./types.js").NullType;
1127
- Float: import("./types.js").NullType;
1128
- String: import("./types.js").NullType;
1129
- DateTime: import("./types.js").NullType;
1130
- Blob: import("./types.js").NullType;
1131
- Ref: import("./types.js").RecursiveTypeMarker;
1132
- Array: import("./types.js").RecursiveTypeMarker;
1133
- Set: import("./types.js").RecursiveTypeMarker;
1134
- Dict: StructType<{
1135
- key: import("./types.js").RecursiveTypeMarker;
1136
- value: import("./types.js").RecursiveTypeMarker;
1137
- }>;
1138
- Struct: ArrayType<StructType<{
1139
- name: StringType;
1140
- type: import("./types.js").RecursiveTypeMarker;
1141
- }>>;
1142
- Variant: ArrayType<StructType<{
1143
- name: StringType;
1144
- type: import("./types.js").RecursiveTypeMarker;
1145
- }>>;
1146
- Recursive: IntegerType;
1147
- Function: StructType<{
1148
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1149
- output: import("./types.js").RecursiveTypeMarker;
1150
- }>;
1151
- AsyncFunction: StructType<{
1152
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1153
- output: import("./types.js").RecursiveTypeMarker;
1122
+ readonly IfElse: StructType<{
1123
+ readonly type: RecursiveType<VariantType<{
1124
+ readonly Never: import("./types.js").NullType;
1125
+ readonly Null: import("./types.js").NullType;
1126
+ readonly Boolean: import("./types.js").NullType;
1127
+ readonly Integer: import("./types.js").NullType;
1128
+ readonly Float: import("./types.js").NullType;
1129
+ readonly String: import("./types.js").NullType;
1130
+ readonly DateTime: import("./types.js").NullType;
1131
+ readonly Blob: import("./types.js").NullType;
1132
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1133
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1134
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1135
+ readonly Dict: StructType<{
1136
+ readonly key: import("./types.js").RecursiveTypeMarker;
1137
+ readonly value: import("./types.js").RecursiveTypeMarker;
1138
+ }>;
1139
+ readonly Struct: ArrayType<StructType<{
1140
+ readonly name: StringType;
1141
+ readonly type: import("./types.js").RecursiveTypeMarker;
1142
+ }>>;
1143
+ readonly Variant: ArrayType<StructType<{
1144
+ readonly name: StringType;
1145
+ readonly type: import("./types.js").RecursiveTypeMarker;
1146
+ }>>;
1147
+ readonly Recursive: IntegerType;
1148
+ readonly Function: StructType<{
1149
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1150
+ readonly output: import("./types.js").RecursiveTypeMarker;
1151
+ }>;
1152
+ readonly AsyncFunction: StructType<{
1153
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1154
+ readonly output: import("./types.js").RecursiveTypeMarker;
1154
1155
  }>;
1155
1156
  }>>;
1156
- location: StructType<{
1157
- filename: StringType;
1158
- line: IntegerType;
1159
- column: IntegerType;
1157
+ readonly location: StructType<{
1158
+ readonly filename: StringType;
1159
+ readonly line: IntegerType;
1160
+ readonly column: IntegerType;
1160
1161
  }>;
1161
- ifs: ArrayType<StructType<{
1162
- predicate: import("./types.js").RecursiveTypeMarker;
1163
- body: import("./types.js").RecursiveTypeMarker;
1162
+ readonly ifs: ArrayType<StructType<{
1163
+ readonly predicate: import("./types.js").RecursiveTypeMarker;
1164
+ readonly body: import("./types.js").RecursiveTypeMarker;
1164
1165
  }>>;
1165
- else_body: import("./types.js").RecursiveTypeMarker;
1166
+ readonly else_body: import("./types.js").RecursiveTypeMarker;
1166
1167
  }>;
1167
- Match: StructType<{
1168
- type: RecursiveType<VariantType<{
1169
- Never: import("./types.js").NullType;
1170
- Null: import("./types.js").NullType;
1171
- Boolean: import("./types.js").NullType;
1172
- Integer: import("./types.js").NullType;
1173
- Float: import("./types.js").NullType;
1174
- String: import("./types.js").NullType;
1175
- DateTime: import("./types.js").NullType;
1176
- Blob: import("./types.js").NullType;
1177
- Ref: import("./types.js").RecursiveTypeMarker;
1178
- Array: import("./types.js").RecursiveTypeMarker;
1179
- Set: import("./types.js").RecursiveTypeMarker;
1180
- Dict: StructType<{
1181
- key: import("./types.js").RecursiveTypeMarker;
1182
- value: import("./types.js").RecursiveTypeMarker;
1183
- }>;
1184
- Struct: ArrayType<StructType<{
1185
- name: StringType;
1186
- type: import("./types.js").RecursiveTypeMarker;
1187
- }>>;
1188
- Variant: ArrayType<StructType<{
1189
- name: StringType;
1190
- type: import("./types.js").RecursiveTypeMarker;
1191
- }>>;
1192
- Recursive: IntegerType;
1193
- Function: StructType<{
1194
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1195
- output: import("./types.js").RecursiveTypeMarker;
1196
- }>;
1197
- AsyncFunction: StructType<{
1198
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1199
- output: import("./types.js").RecursiveTypeMarker;
1168
+ readonly Match: StructType<{
1169
+ readonly type: RecursiveType<VariantType<{
1170
+ readonly Never: import("./types.js").NullType;
1171
+ readonly Null: import("./types.js").NullType;
1172
+ readonly Boolean: import("./types.js").NullType;
1173
+ readonly Integer: import("./types.js").NullType;
1174
+ readonly Float: import("./types.js").NullType;
1175
+ readonly String: import("./types.js").NullType;
1176
+ readonly DateTime: import("./types.js").NullType;
1177
+ readonly Blob: import("./types.js").NullType;
1178
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1179
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1180
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1181
+ readonly Dict: StructType<{
1182
+ readonly key: import("./types.js").RecursiveTypeMarker;
1183
+ readonly value: import("./types.js").RecursiveTypeMarker;
1184
+ }>;
1185
+ readonly Struct: ArrayType<StructType<{
1186
+ readonly name: StringType;
1187
+ readonly type: import("./types.js").RecursiveTypeMarker;
1188
+ }>>;
1189
+ readonly Variant: ArrayType<StructType<{
1190
+ readonly name: StringType;
1191
+ readonly type: import("./types.js").RecursiveTypeMarker;
1192
+ }>>;
1193
+ readonly Recursive: IntegerType;
1194
+ readonly Function: StructType<{
1195
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1196
+ readonly output: import("./types.js").RecursiveTypeMarker;
1197
+ }>;
1198
+ readonly AsyncFunction: StructType<{
1199
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1200
+ readonly output: import("./types.js").RecursiveTypeMarker;
1200
1201
  }>;
1201
1202
  }>>;
1202
- location: StructType<{
1203
- filename: StringType;
1204
- line: IntegerType;
1205
- column: IntegerType;
1203
+ readonly location: StructType<{
1204
+ readonly filename: StringType;
1205
+ readonly line: IntegerType;
1206
+ readonly column: IntegerType;
1206
1207
  }>;
1207
- variant: import("./types.js").RecursiveTypeMarker;
1208
- cases: ArrayType<StructType<{
1209
- case: StringType;
1210
- variable: import("./types.js").RecursiveTypeMarker;
1211
- body: import("./types.js").RecursiveTypeMarker;
1208
+ readonly variant: import("./types.js").RecursiveTypeMarker;
1209
+ readonly cases: ArrayType<StructType<{
1210
+ readonly case: StringType;
1211
+ readonly variable: import("./types.js").RecursiveTypeMarker;
1212
+ readonly body: import("./types.js").RecursiveTypeMarker;
1212
1213
  }>>;
1213
1214
  }>;
1214
- UnwrapRecursive: StructType<{
1215
- type: RecursiveType<VariantType<{
1216
- Never: import("./types.js").NullType;
1217
- Null: import("./types.js").NullType;
1218
- Boolean: import("./types.js").NullType;
1219
- Integer: import("./types.js").NullType;
1220
- Float: import("./types.js").NullType;
1221
- String: import("./types.js").NullType;
1222
- DateTime: import("./types.js").NullType;
1223
- Blob: import("./types.js").NullType;
1224
- Ref: import("./types.js").RecursiveTypeMarker;
1225
- Array: import("./types.js").RecursiveTypeMarker;
1226
- Set: import("./types.js").RecursiveTypeMarker;
1227
- Dict: StructType<{
1228
- key: import("./types.js").RecursiveTypeMarker;
1229
- value: import("./types.js").RecursiveTypeMarker;
1230
- }>;
1231
- Struct: ArrayType<StructType<{
1232
- name: StringType;
1233
- type: import("./types.js").RecursiveTypeMarker;
1234
- }>>;
1235
- Variant: ArrayType<StructType<{
1236
- name: StringType;
1237
- type: import("./types.js").RecursiveTypeMarker;
1238
- }>>;
1239
- Recursive: IntegerType;
1240
- Function: StructType<{
1241
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1242
- output: import("./types.js").RecursiveTypeMarker;
1243
- }>;
1244
- AsyncFunction: StructType<{
1245
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1246
- output: import("./types.js").RecursiveTypeMarker;
1215
+ readonly UnwrapRecursive: StructType<{
1216
+ readonly type: RecursiveType<VariantType<{
1217
+ readonly Never: import("./types.js").NullType;
1218
+ readonly Null: import("./types.js").NullType;
1219
+ readonly Boolean: import("./types.js").NullType;
1220
+ readonly Integer: import("./types.js").NullType;
1221
+ readonly Float: import("./types.js").NullType;
1222
+ readonly String: import("./types.js").NullType;
1223
+ readonly DateTime: import("./types.js").NullType;
1224
+ readonly Blob: import("./types.js").NullType;
1225
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1226
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1227
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1228
+ readonly Dict: StructType<{
1229
+ readonly key: import("./types.js").RecursiveTypeMarker;
1230
+ readonly value: import("./types.js").RecursiveTypeMarker;
1231
+ }>;
1232
+ readonly Struct: ArrayType<StructType<{
1233
+ readonly name: StringType;
1234
+ readonly type: import("./types.js").RecursiveTypeMarker;
1235
+ }>>;
1236
+ readonly Variant: ArrayType<StructType<{
1237
+ readonly name: StringType;
1238
+ readonly type: import("./types.js").RecursiveTypeMarker;
1239
+ }>>;
1240
+ readonly Recursive: IntegerType;
1241
+ readonly Function: StructType<{
1242
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1243
+ readonly output: import("./types.js").RecursiveTypeMarker;
1244
+ }>;
1245
+ readonly AsyncFunction: StructType<{
1246
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1247
+ readonly output: import("./types.js").RecursiveTypeMarker;
1247
1248
  }>;
1248
1249
  }>>;
1249
- location: StructType<{
1250
- filename: StringType;
1251
- line: IntegerType;
1252
- column: IntegerType;
1250
+ readonly location: StructType<{
1251
+ readonly filename: StringType;
1252
+ readonly line: IntegerType;
1253
+ readonly column: IntegerType;
1253
1254
  }>;
1254
- value: import("./types.js").RecursiveTypeMarker;
1255
+ readonly value: import("./types.js").RecursiveTypeMarker;
1255
1256
  }>;
1256
- WrapRecursive: StructType<{
1257
- type: RecursiveType<VariantType<{
1258
- Never: import("./types.js").NullType;
1259
- Null: import("./types.js").NullType;
1260
- Boolean: import("./types.js").NullType;
1261
- Integer: import("./types.js").NullType;
1262
- Float: import("./types.js").NullType;
1263
- String: import("./types.js").NullType;
1264
- DateTime: import("./types.js").NullType;
1265
- Blob: import("./types.js").NullType;
1266
- Ref: import("./types.js").RecursiveTypeMarker;
1267
- Array: import("./types.js").RecursiveTypeMarker;
1268
- Set: import("./types.js").RecursiveTypeMarker;
1269
- Dict: StructType<{
1270
- key: import("./types.js").RecursiveTypeMarker;
1271
- value: import("./types.js").RecursiveTypeMarker;
1272
- }>;
1273
- Struct: ArrayType<StructType<{
1274
- name: StringType;
1275
- type: import("./types.js").RecursiveTypeMarker;
1276
- }>>;
1277
- Variant: ArrayType<StructType<{
1278
- name: StringType;
1279
- type: import("./types.js").RecursiveTypeMarker;
1280
- }>>;
1281
- Recursive: IntegerType;
1282
- Function: StructType<{
1283
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1284
- output: import("./types.js").RecursiveTypeMarker;
1285
- }>;
1286
- AsyncFunction: StructType<{
1287
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1288
- output: import("./types.js").RecursiveTypeMarker;
1257
+ readonly WrapRecursive: StructType<{
1258
+ readonly type: RecursiveType<VariantType<{
1259
+ readonly Never: import("./types.js").NullType;
1260
+ readonly Null: import("./types.js").NullType;
1261
+ readonly Boolean: import("./types.js").NullType;
1262
+ readonly Integer: import("./types.js").NullType;
1263
+ readonly Float: import("./types.js").NullType;
1264
+ readonly String: import("./types.js").NullType;
1265
+ readonly DateTime: import("./types.js").NullType;
1266
+ readonly Blob: import("./types.js").NullType;
1267
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1268
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1269
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1270
+ readonly Dict: StructType<{
1271
+ readonly key: import("./types.js").RecursiveTypeMarker;
1272
+ readonly value: import("./types.js").RecursiveTypeMarker;
1273
+ }>;
1274
+ readonly Struct: ArrayType<StructType<{
1275
+ readonly name: StringType;
1276
+ readonly type: import("./types.js").RecursiveTypeMarker;
1277
+ }>>;
1278
+ readonly Variant: ArrayType<StructType<{
1279
+ readonly name: StringType;
1280
+ readonly type: import("./types.js").RecursiveTypeMarker;
1281
+ }>>;
1282
+ readonly Recursive: IntegerType;
1283
+ readonly Function: StructType<{
1284
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1285
+ readonly output: import("./types.js").RecursiveTypeMarker;
1286
+ }>;
1287
+ readonly AsyncFunction: StructType<{
1288
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1289
+ readonly output: import("./types.js").RecursiveTypeMarker;
1289
1290
  }>;
1290
1291
  }>>;
1291
- location: StructType<{
1292
- filename: StringType;
1293
- line: IntegerType;
1294
- column: IntegerType;
1292
+ readonly location: StructType<{
1293
+ readonly filename: StringType;
1294
+ readonly line: IntegerType;
1295
+ readonly column: IntegerType;
1295
1296
  }>;
1296
- value: import("./types.js").RecursiveTypeMarker;
1297
+ readonly value: import("./types.js").RecursiveTypeMarker;
1297
1298
  }>;
1298
- While: StructType<{
1299
- type: RecursiveType<VariantType<{
1300
- Never: import("./types.js").NullType;
1301
- Null: import("./types.js").NullType;
1302
- Boolean: import("./types.js").NullType;
1303
- Integer: import("./types.js").NullType;
1304
- Float: import("./types.js").NullType;
1305
- String: import("./types.js").NullType;
1306
- DateTime: import("./types.js").NullType;
1307
- Blob: import("./types.js").NullType;
1308
- Ref: import("./types.js").RecursiveTypeMarker;
1309
- Array: import("./types.js").RecursiveTypeMarker;
1310
- Set: import("./types.js").RecursiveTypeMarker;
1311
- Dict: StructType<{
1312
- key: import("./types.js").RecursiveTypeMarker;
1313
- value: import("./types.js").RecursiveTypeMarker;
1314
- }>;
1315
- Struct: ArrayType<StructType<{
1316
- name: StringType;
1317
- type: import("./types.js").RecursiveTypeMarker;
1318
- }>>;
1319
- Variant: ArrayType<StructType<{
1320
- name: StringType;
1321
- type: import("./types.js").RecursiveTypeMarker;
1322
- }>>;
1323
- Recursive: IntegerType;
1324
- Function: StructType<{
1325
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1326
- output: import("./types.js").RecursiveTypeMarker;
1327
- }>;
1328
- AsyncFunction: StructType<{
1329
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1330
- output: import("./types.js").RecursiveTypeMarker;
1299
+ readonly While: StructType<{
1300
+ readonly type: RecursiveType<VariantType<{
1301
+ readonly Never: import("./types.js").NullType;
1302
+ readonly Null: import("./types.js").NullType;
1303
+ readonly Boolean: import("./types.js").NullType;
1304
+ readonly Integer: import("./types.js").NullType;
1305
+ readonly Float: import("./types.js").NullType;
1306
+ readonly String: import("./types.js").NullType;
1307
+ readonly DateTime: import("./types.js").NullType;
1308
+ readonly Blob: import("./types.js").NullType;
1309
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1310
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1311
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1312
+ readonly Dict: StructType<{
1313
+ readonly key: import("./types.js").RecursiveTypeMarker;
1314
+ readonly value: import("./types.js").RecursiveTypeMarker;
1315
+ }>;
1316
+ readonly Struct: ArrayType<StructType<{
1317
+ readonly name: StringType;
1318
+ readonly type: import("./types.js").RecursiveTypeMarker;
1319
+ }>>;
1320
+ readonly Variant: ArrayType<StructType<{
1321
+ readonly name: StringType;
1322
+ readonly type: import("./types.js").RecursiveTypeMarker;
1323
+ }>>;
1324
+ readonly Recursive: IntegerType;
1325
+ readonly Function: StructType<{
1326
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1327
+ readonly output: import("./types.js").RecursiveTypeMarker;
1328
+ }>;
1329
+ readonly AsyncFunction: StructType<{
1330
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1331
+ readonly output: import("./types.js").RecursiveTypeMarker;
1331
1332
  }>;
1332
1333
  }>>;
1333
- location: StructType<{
1334
- filename: StringType;
1335
- line: IntegerType;
1336
- column: IntegerType;
1334
+ readonly location: StructType<{
1335
+ readonly filename: StringType;
1336
+ readonly line: IntegerType;
1337
+ readonly column: IntegerType;
1337
1338
  }>;
1338
- predicate: import("./types.js").RecursiveTypeMarker;
1339
- label: StructType<{
1340
- name: StringType;
1341
- location: StructType<{
1342
- filename: StringType;
1343
- line: IntegerType;
1344
- column: IntegerType;
1339
+ readonly predicate: import("./types.js").RecursiveTypeMarker;
1340
+ readonly label: StructType<{
1341
+ readonly name: StringType;
1342
+ readonly location: StructType<{
1343
+ readonly filename: StringType;
1344
+ readonly line: IntegerType;
1345
+ readonly column: IntegerType;
1345
1346
  }>;
1346
1347
  }>;
1347
- body: import("./types.js").RecursiveTypeMarker;
1348
+ readonly body: import("./types.js").RecursiveTypeMarker;
1348
1349
  }>;
1349
- ForArray: StructType<{
1350
- type: RecursiveType<VariantType<{
1351
- Never: import("./types.js").NullType;
1352
- Null: import("./types.js").NullType;
1353
- Boolean: import("./types.js").NullType;
1354
- Integer: import("./types.js").NullType;
1355
- Float: import("./types.js").NullType;
1356
- String: import("./types.js").NullType;
1357
- DateTime: import("./types.js").NullType;
1358
- Blob: import("./types.js").NullType;
1359
- Ref: import("./types.js").RecursiveTypeMarker;
1360
- Array: import("./types.js").RecursiveTypeMarker;
1361
- Set: import("./types.js").RecursiveTypeMarker;
1362
- Dict: StructType<{
1363
- key: import("./types.js").RecursiveTypeMarker;
1364
- value: import("./types.js").RecursiveTypeMarker;
1365
- }>;
1366
- Struct: ArrayType<StructType<{
1367
- name: StringType;
1368
- type: import("./types.js").RecursiveTypeMarker;
1369
- }>>;
1370
- Variant: ArrayType<StructType<{
1371
- name: StringType;
1372
- type: import("./types.js").RecursiveTypeMarker;
1373
- }>>;
1374
- Recursive: IntegerType;
1375
- Function: StructType<{
1376
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1377
- output: import("./types.js").RecursiveTypeMarker;
1378
- }>;
1379
- AsyncFunction: StructType<{
1380
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1381
- output: import("./types.js").RecursiveTypeMarker;
1350
+ readonly ForArray: StructType<{
1351
+ readonly type: RecursiveType<VariantType<{
1352
+ readonly Never: import("./types.js").NullType;
1353
+ readonly Null: import("./types.js").NullType;
1354
+ readonly Boolean: import("./types.js").NullType;
1355
+ readonly Integer: import("./types.js").NullType;
1356
+ readonly Float: import("./types.js").NullType;
1357
+ readonly String: import("./types.js").NullType;
1358
+ readonly DateTime: import("./types.js").NullType;
1359
+ readonly Blob: import("./types.js").NullType;
1360
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1361
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1362
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1363
+ readonly Dict: StructType<{
1364
+ readonly key: import("./types.js").RecursiveTypeMarker;
1365
+ readonly value: import("./types.js").RecursiveTypeMarker;
1366
+ }>;
1367
+ readonly Struct: ArrayType<StructType<{
1368
+ readonly name: StringType;
1369
+ readonly type: import("./types.js").RecursiveTypeMarker;
1370
+ }>>;
1371
+ readonly Variant: ArrayType<StructType<{
1372
+ readonly name: StringType;
1373
+ readonly type: import("./types.js").RecursiveTypeMarker;
1374
+ }>>;
1375
+ readonly Recursive: IntegerType;
1376
+ readonly Function: StructType<{
1377
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1378
+ readonly output: import("./types.js").RecursiveTypeMarker;
1379
+ }>;
1380
+ readonly AsyncFunction: StructType<{
1381
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1382
+ readonly output: import("./types.js").RecursiveTypeMarker;
1382
1383
  }>;
1383
1384
  }>>;
1384
- location: StructType<{
1385
- filename: StringType;
1386
- line: IntegerType;
1387
- column: IntegerType;
1385
+ readonly location: StructType<{
1386
+ readonly filename: StringType;
1387
+ readonly line: IntegerType;
1388
+ readonly column: IntegerType;
1388
1389
  }>;
1389
- array: import("./types.js").RecursiveTypeMarker;
1390
- label: StructType<{
1391
- name: StringType;
1392
- location: StructType<{
1393
- filename: StringType;
1394
- line: IntegerType;
1395
- column: IntegerType;
1390
+ readonly array: import("./types.js").RecursiveTypeMarker;
1391
+ readonly label: StructType<{
1392
+ readonly name: StringType;
1393
+ readonly location: StructType<{
1394
+ readonly filename: StringType;
1395
+ readonly line: IntegerType;
1396
+ readonly column: IntegerType;
1396
1397
  }>;
1397
1398
  }>;
1398
- key: import("./types.js").RecursiveTypeMarker;
1399
- value: import("./types.js").RecursiveTypeMarker;
1400
- body: import("./types.js").RecursiveTypeMarker;
1399
+ readonly key: import("./types.js").RecursiveTypeMarker;
1400
+ readonly value: import("./types.js").RecursiveTypeMarker;
1401
+ readonly body: import("./types.js").RecursiveTypeMarker;
1401
1402
  }>;
1402
- ForSet: StructType<{
1403
- type: RecursiveType<VariantType<{
1404
- Never: import("./types.js").NullType;
1405
- Null: import("./types.js").NullType;
1406
- Boolean: import("./types.js").NullType;
1407
- Integer: import("./types.js").NullType;
1408
- Float: import("./types.js").NullType;
1409
- String: import("./types.js").NullType;
1410
- DateTime: import("./types.js").NullType;
1411
- Blob: import("./types.js").NullType;
1412
- Ref: import("./types.js").RecursiveTypeMarker;
1413
- Array: import("./types.js").RecursiveTypeMarker;
1414
- Set: import("./types.js").RecursiveTypeMarker;
1415
- Dict: StructType<{
1416
- key: import("./types.js").RecursiveTypeMarker;
1417
- value: import("./types.js").RecursiveTypeMarker;
1418
- }>;
1419
- Struct: ArrayType<StructType<{
1420
- name: StringType;
1421
- type: import("./types.js").RecursiveTypeMarker;
1422
- }>>;
1423
- Variant: ArrayType<StructType<{
1424
- name: StringType;
1425
- type: import("./types.js").RecursiveTypeMarker;
1426
- }>>;
1427
- Recursive: IntegerType;
1428
- Function: StructType<{
1429
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1430
- output: import("./types.js").RecursiveTypeMarker;
1431
- }>;
1432
- AsyncFunction: StructType<{
1433
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1434
- output: import("./types.js").RecursiveTypeMarker;
1403
+ readonly ForSet: StructType<{
1404
+ readonly type: RecursiveType<VariantType<{
1405
+ readonly Never: import("./types.js").NullType;
1406
+ readonly Null: import("./types.js").NullType;
1407
+ readonly Boolean: import("./types.js").NullType;
1408
+ readonly Integer: import("./types.js").NullType;
1409
+ readonly Float: import("./types.js").NullType;
1410
+ readonly String: import("./types.js").NullType;
1411
+ readonly DateTime: import("./types.js").NullType;
1412
+ readonly Blob: import("./types.js").NullType;
1413
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1414
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1415
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1416
+ readonly Dict: StructType<{
1417
+ readonly key: import("./types.js").RecursiveTypeMarker;
1418
+ readonly value: import("./types.js").RecursiveTypeMarker;
1419
+ }>;
1420
+ readonly Struct: ArrayType<StructType<{
1421
+ readonly name: StringType;
1422
+ readonly type: import("./types.js").RecursiveTypeMarker;
1423
+ }>>;
1424
+ readonly Variant: ArrayType<StructType<{
1425
+ readonly name: StringType;
1426
+ readonly type: import("./types.js").RecursiveTypeMarker;
1427
+ }>>;
1428
+ readonly Recursive: IntegerType;
1429
+ readonly Function: StructType<{
1430
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1431
+ readonly output: import("./types.js").RecursiveTypeMarker;
1432
+ }>;
1433
+ readonly AsyncFunction: StructType<{
1434
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1435
+ readonly output: import("./types.js").RecursiveTypeMarker;
1435
1436
  }>;
1436
1437
  }>>;
1437
- location: StructType<{
1438
- filename: StringType;
1439
- line: IntegerType;
1440
- column: IntegerType;
1438
+ readonly location: StructType<{
1439
+ readonly filename: StringType;
1440
+ readonly line: IntegerType;
1441
+ readonly column: IntegerType;
1441
1442
  }>;
1442
- set: import("./types.js").RecursiveTypeMarker;
1443
- label: StructType<{
1444
- name: StringType;
1445
- location: StructType<{
1446
- filename: StringType;
1447
- line: IntegerType;
1448
- column: IntegerType;
1443
+ readonly set: import("./types.js").RecursiveTypeMarker;
1444
+ readonly label: StructType<{
1445
+ readonly name: StringType;
1446
+ readonly location: StructType<{
1447
+ readonly filename: StringType;
1448
+ readonly line: IntegerType;
1449
+ readonly column: IntegerType;
1449
1450
  }>;
1450
1451
  }>;
1451
- key: import("./types.js").RecursiveTypeMarker;
1452
- body: import("./types.js").RecursiveTypeMarker;
1452
+ readonly key: import("./types.js").RecursiveTypeMarker;
1453
+ readonly body: import("./types.js").RecursiveTypeMarker;
1453
1454
  }>;
1454
- ForDict: StructType<{
1455
- type: RecursiveType<VariantType<{
1456
- Never: import("./types.js").NullType;
1457
- Null: import("./types.js").NullType;
1458
- Boolean: import("./types.js").NullType;
1459
- Integer: import("./types.js").NullType;
1460
- Float: import("./types.js").NullType;
1461
- String: import("./types.js").NullType;
1462
- DateTime: import("./types.js").NullType;
1463
- Blob: import("./types.js").NullType;
1464
- Ref: import("./types.js").RecursiveTypeMarker;
1465
- Array: import("./types.js").RecursiveTypeMarker;
1466
- Set: import("./types.js").RecursiveTypeMarker;
1467
- Dict: StructType<{
1468
- key: import("./types.js").RecursiveTypeMarker;
1469
- value: import("./types.js").RecursiveTypeMarker;
1470
- }>;
1471
- Struct: ArrayType<StructType<{
1472
- name: StringType;
1473
- type: import("./types.js").RecursiveTypeMarker;
1474
- }>>;
1475
- Variant: ArrayType<StructType<{
1476
- name: StringType;
1477
- type: import("./types.js").RecursiveTypeMarker;
1478
- }>>;
1479
- Recursive: IntegerType;
1480
- Function: StructType<{
1481
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1482
- output: import("./types.js").RecursiveTypeMarker;
1483
- }>;
1484
- AsyncFunction: StructType<{
1485
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1486
- output: import("./types.js").RecursiveTypeMarker;
1455
+ readonly ForDict: StructType<{
1456
+ readonly type: RecursiveType<VariantType<{
1457
+ readonly Never: import("./types.js").NullType;
1458
+ readonly Null: import("./types.js").NullType;
1459
+ readonly Boolean: import("./types.js").NullType;
1460
+ readonly Integer: import("./types.js").NullType;
1461
+ readonly Float: import("./types.js").NullType;
1462
+ readonly String: import("./types.js").NullType;
1463
+ readonly DateTime: import("./types.js").NullType;
1464
+ readonly Blob: import("./types.js").NullType;
1465
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1466
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1467
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1468
+ readonly Dict: StructType<{
1469
+ readonly key: import("./types.js").RecursiveTypeMarker;
1470
+ readonly value: import("./types.js").RecursiveTypeMarker;
1471
+ }>;
1472
+ readonly Struct: ArrayType<StructType<{
1473
+ readonly name: StringType;
1474
+ readonly type: import("./types.js").RecursiveTypeMarker;
1475
+ }>>;
1476
+ readonly Variant: ArrayType<StructType<{
1477
+ readonly name: StringType;
1478
+ readonly type: import("./types.js").RecursiveTypeMarker;
1479
+ }>>;
1480
+ readonly Recursive: IntegerType;
1481
+ readonly Function: StructType<{
1482
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1483
+ readonly output: import("./types.js").RecursiveTypeMarker;
1484
+ }>;
1485
+ readonly AsyncFunction: StructType<{
1486
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1487
+ readonly output: import("./types.js").RecursiveTypeMarker;
1487
1488
  }>;
1488
1489
  }>>;
1489
- location: StructType<{
1490
- filename: StringType;
1491
- line: IntegerType;
1492
- column: IntegerType;
1490
+ readonly location: StructType<{
1491
+ readonly filename: StringType;
1492
+ readonly line: IntegerType;
1493
+ readonly column: IntegerType;
1493
1494
  }>;
1494
- dict: import("./types.js").RecursiveTypeMarker;
1495
- label: StructType<{
1496
- name: StringType;
1497
- location: StructType<{
1498
- filename: StringType;
1499
- line: IntegerType;
1500
- column: IntegerType;
1495
+ readonly dict: import("./types.js").RecursiveTypeMarker;
1496
+ readonly label: StructType<{
1497
+ readonly name: StringType;
1498
+ readonly location: StructType<{
1499
+ readonly filename: StringType;
1500
+ readonly line: IntegerType;
1501
+ readonly column: IntegerType;
1501
1502
  }>;
1502
1503
  }>;
1503
- key: import("./types.js").RecursiveTypeMarker;
1504
- value: import("./types.js").RecursiveTypeMarker;
1505
- body: import("./types.js").RecursiveTypeMarker;
1504
+ readonly key: import("./types.js").RecursiveTypeMarker;
1505
+ readonly value: import("./types.js").RecursiveTypeMarker;
1506
+ readonly body: import("./types.js").RecursiveTypeMarker;
1506
1507
  }>;
1507
- Return: StructType<{
1508
- type: RecursiveType<VariantType<{
1509
- Never: import("./types.js").NullType;
1510
- Null: import("./types.js").NullType;
1511
- Boolean: import("./types.js").NullType;
1512
- Integer: import("./types.js").NullType;
1513
- Float: import("./types.js").NullType;
1514
- String: import("./types.js").NullType;
1515
- DateTime: import("./types.js").NullType;
1516
- Blob: import("./types.js").NullType;
1517
- Ref: import("./types.js").RecursiveTypeMarker;
1518
- Array: import("./types.js").RecursiveTypeMarker;
1519
- Set: import("./types.js").RecursiveTypeMarker;
1520
- Dict: StructType<{
1521
- key: import("./types.js").RecursiveTypeMarker;
1522
- value: import("./types.js").RecursiveTypeMarker;
1523
- }>;
1524
- Struct: ArrayType<StructType<{
1525
- name: StringType;
1526
- type: import("./types.js").RecursiveTypeMarker;
1527
- }>>;
1528
- Variant: ArrayType<StructType<{
1529
- name: StringType;
1530
- type: import("./types.js").RecursiveTypeMarker;
1531
- }>>;
1532
- Recursive: IntegerType;
1533
- Function: StructType<{
1534
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1535
- output: import("./types.js").RecursiveTypeMarker;
1536
- }>;
1537
- AsyncFunction: StructType<{
1538
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1539
- output: import("./types.js").RecursiveTypeMarker;
1508
+ readonly Return: StructType<{
1509
+ readonly type: RecursiveType<VariantType<{
1510
+ readonly Never: import("./types.js").NullType;
1511
+ readonly Null: import("./types.js").NullType;
1512
+ readonly Boolean: import("./types.js").NullType;
1513
+ readonly Integer: import("./types.js").NullType;
1514
+ readonly Float: import("./types.js").NullType;
1515
+ readonly String: import("./types.js").NullType;
1516
+ readonly DateTime: import("./types.js").NullType;
1517
+ readonly Blob: import("./types.js").NullType;
1518
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1519
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1520
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1521
+ readonly Dict: StructType<{
1522
+ readonly key: import("./types.js").RecursiveTypeMarker;
1523
+ readonly value: import("./types.js").RecursiveTypeMarker;
1524
+ }>;
1525
+ readonly Struct: ArrayType<StructType<{
1526
+ readonly name: StringType;
1527
+ readonly type: import("./types.js").RecursiveTypeMarker;
1528
+ }>>;
1529
+ readonly Variant: ArrayType<StructType<{
1530
+ readonly name: StringType;
1531
+ readonly type: import("./types.js").RecursiveTypeMarker;
1532
+ }>>;
1533
+ readonly Recursive: IntegerType;
1534
+ readonly Function: StructType<{
1535
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1536
+ readonly output: import("./types.js").RecursiveTypeMarker;
1537
+ }>;
1538
+ readonly AsyncFunction: StructType<{
1539
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1540
+ readonly output: import("./types.js").RecursiveTypeMarker;
1540
1541
  }>;
1541
1542
  }>>;
1542
- location: StructType<{
1543
- filename: StringType;
1544
- line: IntegerType;
1545
- column: IntegerType;
1543
+ readonly location: StructType<{
1544
+ readonly filename: StringType;
1545
+ readonly line: IntegerType;
1546
+ readonly column: IntegerType;
1546
1547
  }>;
1547
- value: import("./types.js").RecursiveTypeMarker;
1548
+ readonly value: import("./types.js").RecursiveTypeMarker;
1548
1549
  }>;
1549
- Continue: StructType<{
1550
- type: RecursiveType<VariantType<{
1551
- Never: import("./types.js").NullType;
1552
- Null: import("./types.js").NullType;
1553
- Boolean: import("./types.js").NullType;
1554
- Integer: import("./types.js").NullType;
1555
- Float: import("./types.js").NullType;
1556
- String: import("./types.js").NullType;
1557
- DateTime: import("./types.js").NullType;
1558
- Blob: import("./types.js").NullType;
1559
- Ref: import("./types.js").RecursiveTypeMarker;
1560
- Array: import("./types.js").RecursiveTypeMarker;
1561
- Set: import("./types.js").RecursiveTypeMarker;
1562
- Dict: StructType<{
1563
- key: import("./types.js").RecursiveTypeMarker;
1564
- value: import("./types.js").RecursiveTypeMarker;
1565
- }>;
1566
- Struct: ArrayType<StructType<{
1567
- name: StringType;
1568
- type: import("./types.js").RecursiveTypeMarker;
1569
- }>>;
1570
- Variant: ArrayType<StructType<{
1571
- name: StringType;
1572
- type: import("./types.js").RecursiveTypeMarker;
1573
- }>>;
1574
- Recursive: IntegerType;
1575
- Function: StructType<{
1576
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1577
- output: import("./types.js").RecursiveTypeMarker;
1578
- }>;
1579
- AsyncFunction: StructType<{
1580
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1581
- output: import("./types.js").RecursiveTypeMarker;
1550
+ readonly Continue: StructType<{
1551
+ readonly type: RecursiveType<VariantType<{
1552
+ readonly Never: import("./types.js").NullType;
1553
+ readonly Null: import("./types.js").NullType;
1554
+ readonly Boolean: import("./types.js").NullType;
1555
+ readonly Integer: import("./types.js").NullType;
1556
+ readonly Float: import("./types.js").NullType;
1557
+ readonly String: import("./types.js").NullType;
1558
+ readonly DateTime: import("./types.js").NullType;
1559
+ readonly Blob: import("./types.js").NullType;
1560
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1561
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1562
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1563
+ readonly Dict: StructType<{
1564
+ readonly key: import("./types.js").RecursiveTypeMarker;
1565
+ readonly value: import("./types.js").RecursiveTypeMarker;
1566
+ }>;
1567
+ readonly Struct: ArrayType<StructType<{
1568
+ readonly name: StringType;
1569
+ readonly type: import("./types.js").RecursiveTypeMarker;
1570
+ }>>;
1571
+ readonly Variant: ArrayType<StructType<{
1572
+ readonly name: StringType;
1573
+ readonly type: import("./types.js").RecursiveTypeMarker;
1574
+ }>>;
1575
+ readonly Recursive: IntegerType;
1576
+ readonly Function: StructType<{
1577
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1578
+ readonly output: import("./types.js").RecursiveTypeMarker;
1579
+ }>;
1580
+ readonly AsyncFunction: StructType<{
1581
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1582
+ readonly output: import("./types.js").RecursiveTypeMarker;
1582
1583
  }>;
1583
1584
  }>>;
1584
- location: StructType<{
1585
- filename: StringType;
1586
- line: IntegerType;
1587
- column: IntegerType;
1585
+ readonly location: StructType<{
1586
+ readonly filename: StringType;
1587
+ readonly line: IntegerType;
1588
+ readonly column: IntegerType;
1588
1589
  }>;
1589
- label: StructType<{
1590
- name: StringType;
1591
- location: StructType<{
1592
- filename: StringType;
1593
- line: IntegerType;
1594
- column: IntegerType;
1590
+ readonly label: StructType<{
1591
+ readonly name: StringType;
1592
+ readonly location: StructType<{
1593
+ readonly filename: StringType;
1594
+ readonly line: IntegerType;
1595
+ readonly column: IntegerType;
1595
1596
  }>;
1596
1597
  }>;
1597
1598
  }>;
1598
- Break: StructType<{
1599
- type: RecursiveType<VariantType<{
1600
- Never: import("./types.js").NullType;
1601
- Null: import("./types.js").NullType;
1602
- Boolean: import("./types.js").NullType;
1603
- Integer: import("./types.js").NullType;
1604
- Float: import("./types.js").NullType;
1605
- String: import("./types.js").NullType;
1606
- DateTime: import("./types.js").NullType;
1607
- Blob: import("./types.js").NullType;
1608
- Ref: import("./types.js").RecursiveTypeMarker;
1609
- Array: import("./types.js").RecursiveTypeMarker;
1610
- Set: import("./types.js").RecursiveTypeMarker;
1611
- Dict: StructType<{
1612
- key: import("./types.js").RecursiveTypeMarker;
1613
- value: import("./types.js").RecursiveTypeMarker;
1614
- }>;
1615
- Struct: ArrayType<StructType<{
1616
- name: StringType;
1617
- type: import("./types.js").RecursiveTypeMarker;
1618
- }>>;
1619
- Variant: ArrayType<StructType<{
1620
- name: StringType;
1621
- type: import("./types.js").RecursiveTypeMarker;
1622
- }>>;
1623
- Recursive: IntegerType;
1624
- Function: StructType<{
1625
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1626
- output: import("./types.js").RecursiveTypeMarker;
1627
- }>;
1628
- AsyncFunction: StructType<{
1629
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1630
- output: import("./types.js").RecursiveTypeMarker;
1599
+ readonly Break: StructType<{
1600
+ readonly type: RecursiveType<VariantType<{
1601
+ readonly Never: import("./types.js").NullType;
1602
+ readonly Null: import("./types.js").NullType;
1603
+ readonly Boolean: import("./types.js").NullType;
1604
+ readonly Integer: import("./types.js").NullType;
1605
+ readonly Float: import("./types.js").NullType;
1606
+ readonly String: import("./types.js").NullType;
1607
+ readonly DateTime: import("./types.js").NullType;
1608
+ readonly Blob: import("./types.js").NullType;
1609
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1610
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1611
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1612
+ readonly Dict: StructType<{
1613
+ readonly key: import("./types.js").RecursiveTypeMarker;
1614
+ readonly value: import("./types.js").RecursiveTypeMarker;
1615
+ }>;
1616
+ readonly Struct: ArrayType<StructType<{
1617
+ readonly name: StringType;
1618
+ readonly type: import("./types.js").RecursiveTypeMarker;
1619
+ }>>;
1620
+ readonly Variant: ArrayType<StructType<{
1621
+ readonly name: StringType;
1622
+ readonly type: import("./types.js").RecursiveTypeMarker;
1623
+ }>>;
1624
+ readonly Recursive: IntegerType;
1625
+ readonly Function: StructType<{
1626
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1627
+ readonly output: import("./types.js").RecursiveTypeMarker;
1628
+ }>;
1629
+ readonly AsyncFunction: StructType<{
1630
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1631
+ readonly output: import("./types.js").RecursiveTypeMarker;
1631
1632
  }>;
1632
1633
  }>>;
1633
- location: StructType<{
1634
- filename: StringType;
1635
- line: IntegerType;
1636
- column: IntegerType;
1634
+ readonly location: StructType<{
1635
+ readonly filename: StringType;
1636
+ readonly line: IntegerType;
1637
+ readonly column: IntegerType;
1637
1638
  }>;
1638
- label: StructType<{
1639
- name: StringType;
1640
- location: StructType<{
1641
- filename: StringType;
1642
- line: IntegerType;
1643
- column: IntegerType;
1639
+ readonly label: StructType<{
1640
+ readonly name: StringType;
1641
+ readonly location: StructType<{
1642
+ readonly filename: StringType;
1643
+ readonly line: IntegerType;
1644
+ readonly column: IntegerType;
1644
1645
  }>;
1645
1646
  }>;
1646
1647
  }>;
1647
- Builtin: StructType<{
1648
- type: RecursiveType<VariantType<{
1649
- Never: import("./types.js").NullType;
1650
- Null: import("./types.js").NullType;
1651
- Boolean: import("./types.js").NullType;
1652
- Integer: import("./types.js").NullType;
1653
- Float: import("./types.js").NullType;
1654
- String: import("./types.js").NullType;
1655
- DateTime: import("./types.js").NullType;
1656
- Blob: import("./types.js").NullType;
1657
- Ref: import("./types.js").RecursiveTypeMarker;
1658
- Array: import("./types.js").RecursiveTypeMarker;
1659
- Set: import("./types.js").RecursiveTypeMarker;
1660
- Dict: StructType<{
1661
- key: import("./types.js").RecursiveTypeMarker;
1662
- value: import("./types.js").RecursiveTypeMarker;
1663
- }>;
1664
- Struct: ArrayType<StructType<{
1665
- name: StringType;
1666
- type: import("./types.js").RecursiveTypeMarker;
1667
- }>>;
1668
- Variant: ArrayType<StructType<{
1669
- name: StringType;
1670
- type: import("./types.js").RecursiveTypeMarker;
1671
- }>>;
1672
- Recursive: IntegerType;
1673
- Function: StructType<{
1674
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1675
- output: import("./types.js").RecursiveTypeMarker;
1676
- }>;
1677
- AsyncFunction: StructType<{
1678
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1679
- output: import("./types.js").RecursiveTypeMarker;
1648
+ readonly Builtin: StructType<{
1649
+ readonly type: RecursiveType<VariantType<{
1650
+ readonly Never: import("./types.js").NullType;
1651
+ readonly Null: import("./types.js").NullType;
1652
+ readonly Boolean: import("./types.js").NullType;
1653
+ readonly Integer: import("./types.js").NullType;
1654
+ readonly Float: import("./types.js").NullType;
1655
+ readonly String: import("./types.js").NullType;
1656
+ readonly DateTime: import("./types.js").NullType;
1657
+ readonly Blob: import("./types.js").NullType;
1658
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1659
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1660
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1661
+ readonly Dict: StructType<{
1662
+ readonly key: import("./types.js").RecursiveTypeMarker;
1663
+ readonly value: import("./types.js").RecursiveTypeMarker;
1664
+ }>;
1665
+ readonly Struct: ArrayType<StructType<{
1666
+ readonly name: StringType;
1667
+ readonly type: import("./types.js").RecursiveTypeMarker;
1668
+ }>>;
1669
+ readonly Variant: ArrayType<StructType<{
1670
+ readonly name: StringType;
1671
+ readonly type: import("./types.js").RecursiveTypeMarker;
1672
+ }>>;
1673
+ readonly Recursive: IntegerType;
1674
+ readonly Function: StructType<{
1675
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1676
+ readonly output: import("./types.js").RecursiveTypeMarker;
1677
+ }>;
1678
+ readonly AsyncFunction: StructType<{
1679
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1680
+ readonly output: import("./types.js").RecursiveTypeMarker;
1680
1681
  }>;
1681
1682
  }>>;
1682
- location: StructType<{
1683
- filename: StringType;
1684
- line: IntegerType;
1685
- column: IntegerType;
1683
+ readonly location: StructType<{
1684
+ readonly filename: StringType;
1685
+ readonly line: IntegerType;
1686
+ readonly column: IntegerType;
1686
1687
  }>;
1687
- builtin: StringType;
1688
- type_parameters: ArrayType<RecursiveType<VariantType<{
1689
- Never: import("./types.js").NullType;
1690
- Null: import("./types.js").NullType;
1691
- Boolean: import("./types.js").NullType;
1692
- Integer: import("./types.js").NullType;
1693
- Float: import("./types.js").NullType;
1694
- String: import("./types.js").NullType;
1695
- DateTime: import("./types.js").NullType;
1696
- Blob: import("./types.js").NullType;
1697
- Ref: import("./types.js").RecursiveTypeMarker;
1698
- Array: import("./types.js").RecursiveTypeMarker;
1699
- Set: import("./types.js").RecursiveTypeMarker;
1700
- Dict: StructType<{
1701
- key: import("./types.js").RecursiveTypeMarker;
1702
- value: import("./types.js").RecursiveTypeMarker;
1703
- }>;
1704
- Struct: ArrayType<StructType<{
1705
- name: StringType;
1706
- type: import("./types.js").RecursiveTypeMarker;
1707
- }>>;
1708
- Variant: ArrayType<StructType<{
1709
- name: StringType;
1710
- type: import("./types.js").RecursiveTypeMarker;
1711
- }>>;
1712
- Recursive: IntegerType;
1713
- Function: StructType<{
1714
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1715
- output: import("./types.js").RecursiveTypeMarker;
1716
- }>;
1717
- AsyncFunction: StructType<{
1718
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1719
- output: import("./types.js").RecursiveTypeMarker;
1688
+ readonly builtin: StringType;
1689
+ readonly type_parameters: ArrayType<RecursiveType<VariantType<{
1690
+ readonly Never: import("./types.js").NullType;
1691
+ readonly Null: import("./types.js").NullType;
1692
+ readonly Boolean: import("./types.js").NullType;
1693
+ readonly Integer: import("./types.js").NullType;
1694
+ readonly Float: import("./types.js").NullType;
1695
+ readonly String: import("./types.js").NullType;
1696
+ readonly DateTime: import("./types.js").NullType;
1697
+ readonly Blob: import("./types.js").NullType;
1698
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1699
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1700
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1701
+ readonly Dict: StructType<{
1702
+ readonly key: import("./types.js").RecursiveTypeMarker;
1703
+ readonly value: import("./types.js").RecursiveTypeMarker;
1704
+ }>;
1705
+ readonly Struct: ArrayType<StructType<{
1706
+ readonly name: StringType;
1707
+ readonly type: import("./types.js").RecursiveTypeMarker;
1708
+ }>>;
1709
+ readonly Variant: ArrayType<StructType<{
1710
+ readonly name: StringType;
1711
+ readonly type: import("./types.js").RecursiveTypeMarker;
1712
+ }>>;
1713
+ readonly Recursive: IntegerType;
1714
+ readonly Function: StructType<{
1715
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1716
+ readonly output: import("./types.js").RecursiveTypeMarker;
1717
+ }>;
1718
+ readonly AsyncFunction: StructType<{
1719
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1720
+ readonly output: import("./types.js").RecursiveTypeMarker;
1720
1721
  }>;
1721
1722
  }>>>;
1722
- arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
1723
+ readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
1723
1724
  }>;
1724
- Platform: StructType<{
1725
- type: RecursiveType<VariantType<{
1726
- Never: import("./types.js").NullType;
1727
- Null: import("./types.js").NullType;
1728
- Boolean: import("./types.js").NullType;
1729
- Integer: import("./types.js").NullType;
1730
- Float: import("./types.js").NullType;
1731
- String: import("./types.js").NullType;
1732
- DateTime: import("./types.js").NullType;
1733
- Blob: import("./types.js").NullType;
1734
- Ref: import("./types.js").RecursiveTypeMarker;
1735
- Array: import("./types.js").RecursiveTypeMarker;
1736
- Set: import("./types.js").RecursiveTypeMarker;
1737
- Dict: StructType<{
1738
- key: import("./types.js").RecursiveTypeMarker;
1739
- value: import("./types.js").RecursiveTypeMarker;
1740
- }>;
1741
- Struct: ArrayType<StructType<{
1742
- name: StringType;
1743
- type: import("./types.js").RecursiveTypeMarker;
1744
- }>>;
1745
- Variant: ArrayType<StructType<{
1746
- name: StringType;
1747
- type: import("./types.js").RecursiveTypeMarker;
1748
- }>>;
1749
- Recursive: IntegerType;
1750
- Function: StructType<{
1751
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1752
- output: import("./types.js").RecursiveTypeMarker;
1753
- }>;
1754
- AsyncFunction: StructType<{
1755
- inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1756
- output: import("./types.js").RecursiveTypeMarker;
1725
+ readonly Platform: StructType<{
1726
+ readonly type: RecursiveType<VariantType<{
1727
+ readonly Never: import("./types.js").NullType;
1728
+ readonly Null: import("./types.js").NullType;
1729
+ readonly Boolean: import("./types.js").NullType;
1730
+ readonly Integer: import("./types.js").NullType;
1731
+ readonly Float: import("./types.js").NullType;
1732
+ readonly String: import("./types.js").NullType;
1733
+ readonly DateTime: import("./types.js").NullType;
1734
+ readonly Blob: import("./types.js").NullType;
1735
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1736
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1737
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1738
+ readonly Dict: StructType<{
1739
+ readonly key: import("./types.js").RecursiveTypeMarker;
1740
+ readonly value: import("./types.js").RecursiveTypeMarker;
1741
+ }>;
1742
+ readonly Struct: ArrayType<StructType<{
1743
+ readonly name: StringType;
1744
+ readonly type: import("./types.js").RecursiveTypeMarker;
1745
+ }>>;
1746
+ readonly Variant: ArrayType<StructType<{
1747
+ readonly name: StringType;
1748
+ readonly type: import("./types.js").RecursiveTypeMarker;
1749
+ }>>;
1750
+ readonly Recursive: IntegerType;
1751
+ readonly Function: StructType<{
1752
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1753
+ readonly output: import("./types.js").RecursiveTypeMarker;
1754
+ }>;
1755
+ readonly AsyncFunction: StructType<{
1756
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1757
+ readonly output: import("./types.js").RecursiveTypeMarker;
1757
1758
  }>;
1758
1759
  }>>;
1759
- location: StructType<{
1760
- filename: StringType;
1761
- line: IntegerType;
1762
- column: IntegerType;
1760
+ readonly location: StructType<{
1761
+ readonly filename: StringType;
1762
+ readonly line: IntegerType;
1763
+ readonly column: IntegerType;
1763
1764
  }>;
1764
- name: StringType;
1765
- arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
1766
- async: BooleanType;
1765
+ readonly name: StringType;
1766
+ readonly type_parameters: ArrayType<RecursiveType<VariantType<{
1767
+ readonly Never: import("./types.js").NullType;
1768
+ readonly Null: import("./types.js").NullType;
1769
+ readonly Boolean: import("./types.js").NullType;
1770
+ readonly Integer: import("./types.js").NullType;
1771
+ readonly Float: import("./types.js").NullType;
1772
+ readonly String: import("./types.js").NullType;
1773
+ readonly DateTime: import("./types.js").NullType;
1774
+ readonly Blob: import("./types.js").NullType;
1775
+ readonly Ref: import("./types.js").RecursiveTypeMarker;
1776
+ readonly Array: import("./types.js").RecursiveTypeMarker;
1777
+ readonly Set: import("./types.js").RecursiveTypeMarker;
1778
+ readonly Dict: StructType<{
1779
+ readonly key: import("./types.js").RecursiveTypeMarker;
1780
+ readonly value: import("./types.js").RecursiveTypeMarker;
1781
+ }>;
1782
+ readonly Struct: ArrayType<StructType<{
1783
+ readonly name: StringType;
1784
+ readonly type: import("./types.js").RecursiveTypeMarker;
1785
+ }>>;
1786
+ readonly Variant: ArrayType<StructType<{
1787
+ readonly name: StringType;
1788
+ readonly type: import("./types.js").RecursiveTypeMarker;
1789
+ }>>;
1790
+ readonly Recursive: IntegerType;
1791
+ readonly Function: StructType<{
1792
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1793
+ readonly output: import("./types.js").RecursiveTypeMarker;
1794
+ }>;
1795
+ readonly AsyncFunction: StructType<{
1796
+ readonly inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
1797
+ readonly output: import("./types.js").RecursiveTypeMarker;
1798
+ }>;
1799
+ }>>>;
1800
+ readonly arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
1801
+ readonly async: BooleanType;
1767
1802
  }>;
1768
1803
  }>>;
1769
1804
  //# sourceMappingURL=ir.d.ts.map