@elaraai/east 0.0.1-beta.0

package/dist/src/ir.d.ts

@@ -0,0 +1,1571 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import type { BuiltinName } from "./builtins.js";
+import type { variant } from "./containers/variant.js";
+import type { EastTypeValue, LiteralValue } from "./type_of_type.js";
+import { ArrayType, BooleanType, IntegerType, RecursiveType, StringType, StructType, VariantType } from "./types.js";
+export type LocationValue = {
+    filename: string;
+    line: bigint;
+    column: bigint;
+};
+export declare function printLocationValue(location: LocationValue): string;
+export type ErrorIR = variant<"Error", {
+    type: variant<"Never", null>;
+    location: LocationValue;
+    message: any;
+}>;
+export type TryCatchIR = variant<"TryCatch", {
+    type: EastTypeValue;
+    location: LocationValue;
+    try_body: any;
+    catch_body: any;
+    message: VariableIR;
+    stack: VariableIR;
+    finally_body: any;
+}>;
+export type ValueIR = variant<"Value", {
+    type: EastTypeValue;
+    location: LocationValue;
+    value: LiteralValue;
+}>;
+export type VariableIR = variant<"Variable", {
+    type: EastTypeValue;
+    name: string;
+    location: LocationValue;
+    mutable: boolean;
+    captured: boolean;
+}>;
+export type LetIR = variant<"Let", {
+    type: EastTypeValue;
+    location: LocationValue;
+    variable: VariableIR;
+    value: any;
+}>;
+export type AssignIR = variant<"Assign", {
+    type: EastTypeValue;
+    location: LocationValue;
+    variable: VariableIR;
+    value: any;
+}>;
+export type AsIR = variant<"As", {
+    type: EastTypeValue;
+    value: any;
+    location: LocationValue;
+}>;
+export type FunctionIR = variant<"Function", {
+    type: EastTypeValue;
+    location: LocationValue;
+    captures: VariableIR[];
+    parameters: VariableIR[];
+    body: any;
+}>;
+export type CallIR = variant<"Call", {
+    type: EastTypeValue;
+    location: LocationValue;
+    function: any;
+    arguments: any[];
+}>;
+export type NewRefIR = variant<"NewRef", {
+    type: EastTypeValue;
+    location: LocationValue;
+    value: any;
+}>;
+export type NewArrayIR = variant<"NewArray", {
+    type: EastTypeValue;
+    location: LocationValue;
+    values: any[];
+}>;
+export type NewSetIR = variant<"NewSet", {
+    type: EastTypeValue;
+    location: LocationValue;
+    values: any[];
+}>;
+export type NewDictIR = variant<"NewDict", {
+    type: EastTypeValue;
+    location: LocationValue;
+    values: {
+        key: any;
+        value: any;
+    }[];
+}>;
+export type StructIR = variant<"Struct", {
+    type: EastTypeValue;
+    location: LocationValue;
+    fields: {
+        name: string;
+        value: any;
+    }[];
+}>;
+export type GetFieldIR = variant<"GetField", {
+    type: EastTypeValue;
+    location: LocationValue;
+    field: string;
+    struct: any;
+}>;
+export type VariantIR = variant<"Variant", {
+    type: EastTypeValue;
+    location: LocationValue;
+    case: string;
+    value: any;
+}>;
+export type BlockIR = variant<"Block", {
+    type: EastTypeValue;
+    location: LocationValue;
+    statements: any[];
+}>;
+export type IfElseIR = variant<"IfElse", {
+    type: EastTypeValue;
+    location: LocationValue;
+    ifs: {
+        predicate: any;
+        body: any;
+    }[];
+    else_body: any;
+}>;
+export type MatchIR = variant<"Match", {
+    type: EastTypeValue;
+    location: LocationValue;
+    variant: any;
+    cases: {
+        case: string;
+        variable: VariableIR;
+        body: any;
+    }[];
+}>;
+export type UnwrapRecursiveIR = variant<"UnwrapRecursive", {
+    type: EastTypeValue;
+    location: LocationValue;
+    value: any;
+}>;
+export type WrapRecursiveIR = variant<"WrapRecursive", {
+    type: EastTypeValue;
+    location: LocationValue;
+    value: any;
+}>;
+export type IRLabel = {
+    name: string;
+    location: LocationValue;
+};
+export type WhileIR = variant<"While", {
+    type: variant<"Null", null>;
+    location: LocationValue;
+    predicate: any;
+    label: IRLabel;
+    body: any;
+}>;
+export type ForArrayIR = variant<"ForArray", {
+    type: variant<"Null", null>;
+    location: LocationValue;
+    array: any;
+    label: IRLabel;
+    key: VariableIR;
+    value: VariableIR;
+    body: any;
+}>;
+export type ForSetIR = variant<"ForSet", {
+    type: variant<"Null", null>;
+    location: LocationValue;
+    set: any;
+    label: IRLabel;
+    key: VariableIR;
+    body: any;
+}>;
+export type ForDictIR = variant<"ForDict", {
+    type: variant<"Null", null>;
+    location: LocationValue;
+    dict: any;
+    label: IRLabel;
+    key: VariableIR;
+    value: VariableIR;
+    body: any;
+}>;
+export type ReturnIR = variant<"Return", {
+    type: variant<"Never", null>;
+    location: LocationValue;
+    value: any;
+}>;
+export type ContinueIR = variant<"Continue", {
+    type: variant<"Never", null>;
+    location: LocationValue;
+    label: IRLabel;
+}>;
+export type BreakIR = variant<"Break", {
+    type: variant<"Never", null>;
+    location: LocationValue;
+    label: IRLabel;
+}>;
+/**@internal */
+export type BuiltinIR = variant<"Builtin", {
+    type: EastTypeValue;
+    location: LocationValue;
+    builtin: BuiltinName;
+    type_parameters: EastTypeValue[];
+    arguments: any[];
+}>;
+export type PlatformIR = variant<"Platform", {
+    type: EastTypeValue;
+    location: LocationValue;
+    name: string;
+    arguments: any[];
+}>;
+/** The common intermediate representation (IR) for East code.
+ *
+ * East IR is an expression-based tree of nodes.
+ * It has been processed from AST and checked for type safety and variable resolution.
+ * The code is ready to be serialized, evaluated or compiled.
+ */
+export type IR = ErrorIR | TryCatchIR | ValueIR | VariableIR | LetIR | AssignIR | AsIR | FunctionIR | CallIR | NewRefIR | NewArrayIR | NewSetIR | NewDictIR | StructIR | GetFieldIR | VariantIR | BlockIR | IfElseIR | MatchIR | UnwrapRecursiveIR | WrapRecursiveIR | WhileIR | ForArrayIR | ForSetIR | ForDictIR | ReturnIR | ContinueIR | BreakIR | BuiltinIR | PlatformIR;
+export declare const LocationType: StructType<{
+    filename: StringType;
+    line: IntegerType;
+    column: IntegerType;
+}>;
+export declare const IRLabelType: StructType<{
+    name: StringType;
+    location: StructType<{
+        filename: StringType;
+        line: IntegerType;
+        column: IntegerType;
+    }>;
+}>;
+export declare const VariableType: StructType<{
+    type: RecursiveType<VariantType<{
+        Never: import("./types.js").NullType;
+        Null: import("./types.js").NullType;
+        Boolean: import("./types.js").NullType;
+        Integer: import("./types.js").NullType;
+        Float: import("./types.js").NullType;
+        String: import("./types.js").NullType;
+        DateTime: import("./types.js").NullType;
+        Blob: import("./types.js").NullType;
+        Ref: import("./types.js").RecursiveTypeMarker;
+        Array: import("./types.js").RecursiveTypeMarker;
+        Set: import("./types.js").RecursiveTypeMarker;
+        Dict: StructType<{
+            key: import("./types.js").RecursiveTypeMarker;
+            value: import("./types.js").RecursiveTypeMarker;
+        }>;
+        Struct: ArrayType<StructType<{
+            name: StringType;
+            type: import("./types.js").RecursiveTypeMarker;
+        }>>;
+        Variant: ArrayType<StructType<{
+            name: StringType;
+            type: import("./types.js").RecursiveTypeMarker;
+        }>>;
+        Recursive: IntegerType;
+        Function: StructType<{
+            inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+            output: import("./types.js").RecursiveTypeMarker;
+            platforms: ArrayType<StringType>;
+        }>;
+    }>>;
+    location: StructType<{
+        filename: StringType;
+        line: IntegerType;
+        column: IntegerType;
+    }>;
+    name: StringType;
+    mutable: BooleanType;
+    captured: BooleanType;
+}>;
+export declare const IRType: RecursiveType<VariantType<{
+    Error: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        message: import("./types.js").RecursiveTypeMarker;
+    }>;
+    TryCatch: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        try_body: import("./types.js").RecursiveTypeMarker;
+        catch_body: import("./types.js").RecursiveTypeMarker;
+        message: import("./types.js").RecursiveTypeMarker;
+        stack: import("./types.js").RecursiveTypeMarker;
+        finally_body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Value: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        value: VariantType<{
+            Null: import("./types.js").NullType;
+            Boolean: BooleanType;
+            Integer: IntegerType;
+            Float: import("./types.js").FloatType;
+            String: StringType;
+            DateTime: import("./types.js").DateTimeType;
+            Blob: import("./types.js").BlobType;
+        }>;
+    }>;
+    Variable: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        name: StringType;
+        mutable: BooleanType;
+        captured: BooleanType;
+    }>;
+    Let: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        variable: import("./types.js").RecursiveTypeMarker;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Assign: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        variable: import("./types.js").RecursiveTypeMarker;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    As: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Function: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        captures: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        parameters: ArrayType<import("./types.js").RecursiveTypeMarker>;
+        body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Call: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        function: import("./types.js").RecursiveTypeMarker;
+        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    NewRef: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    NewArray: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    NewSet: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        values: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    NewDict: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        values: ArrayType<StructType<{
+            key: import("./types.js").RecursiveTypeMarker;
+            value: import("./types.js").RecursiveTypeMarker;
+        }>>;
+    }>;
+    Struct: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        fields: ArrayType<StructType<{
+            name: StringType;
+            value: import("./types.js").RecursiveTypeMarker;
+        }>>;
+    }>;
+    GetField: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        field: StringType;
+        struct: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Variant: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        case: StringType;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Block: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        statements: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    IfElse: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        ifs: ArrayType<StructType<{
+            predicate: import("./types.js").RecursiveTypeMarker;
+            body: import("./types.js").RecursiveTypeMarker;
+        }>>;
+        else_body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Match: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        variant: import("./types.js").RecursiveTypeMarker;
+        cases: ArrayType<StructType<{
+            case: StringType;
+            variable: import("./types.js").RecursiveTypeMarker;
+            body: import("./types.js").RecursiveTypeMarker;
+        }>>;
+    }>;
+    UnwrapRecursive: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    WrapRecursive: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    While: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        predicate: import("./types.js").RecursiveTypeMarker;
+        label: StructType<{
+            name: StringType;
+            location: StructType<{
+                filename: StringType;
+                line: IntegerType;
+                column: IntegerType;
+            }>;
+        }>;
+        body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    ForArray: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        array: import("./types.js").RecursiveTypeMarker;
+        label: StructType<{
+            name: StringType;
+            location: StructType<{
+                filename: StringType;
+                line: IntegerType;
+                column: IntegerType;
+            }>;
+        }>;
+        key: import("./types.js").RecursiveTypeMarker;
+        value: import("./types.js").RecursiveTypeMarker;
+        body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    ForSet: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        set: import("./types.js").RecursiveTypeMarker;
+        label: StructType<{
+            name: StringType;
+            location: StructType<{
+                filename: StringType;
+                line: IntegerType;
+                column: IntegerType;
+            }>;
+        }>;
+        key: import("./types.js").RecursiveTypeMarker;
+        body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    ForDict: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        dict: import("./types.js").RecursiveTypeMarker;
+        label: StructType<{
+            name: StringType;
+            location: StructType<{
+                filename: StringType;
+                line: IntegerType;
+                column: IntegerType;
+            }>;
+        }>;
+        key: import("./types.js").RecursiveTypeMarker;
+        value: import("./types.js").RecursiveTypeMarker;
+        body: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Return: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        value: import("./types.js").RecursiveTypeMarker;
+    }>;
+    Continue: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        label: StructType<{
+            name: StringType;
+            location: StructType<{
+                filename: StringType;
+                line: IntegerType;
+                column: IntegerType;
+            }>;
+        }>;
+    }>;
+    Break: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        label: StructType<{
+            name: StringType;
+            location: StructType<{
+                filename: StringType;
+                line: IntegerType;
+                column: IntegerType;
+            }>;
+        }>;
+    }>;
+    Builtin: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        builtin: StringType;
+        type_parameters: ArrayType<RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>>;
+        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+    Platform: StructType<{
+        type: RecursiveType<VariantType<{
+            Never: import("./types.js").NullType;
+            Null: import("./types.js").NullType;
+            Boolean: import("./types.js").NullType;
+            Integer: import("./types.js").NullType;
+            Float: import("./types.js").NullType;
+            String: import("./types.js").NullType;
+            DateTime: import("./types.js").NullType;
+            Blob: import("./types.js").NullType;
+            Ref: import("./types.js").RecursiveTypeMarker;
+            Array: import("./types.js").RecursiveTypeMarker;
+            Set: import("./types.js").RecursiveTypeMarker;
+            Dict: StructType<{
+                key: import("./types.js").RecursiveTypeMarker;
+                value: import("./types.js").RecursiveTypeMarker;
+            }>;
+            Struct: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Variant: ArrayType<StructType<{
+                name: StringType;
+                type: import("./types.js").RecursiveTypeMarker;
+            }>>;
+            Recursive: IntegerType;
+            Function: StructType<{
+                inputs: ArrayType<import("./types.js").RecursiveTypeMarker>;
+                output: import("./types.js").RecursiveTypeMarker;
+                platforms: ArrayType<StringType>;
+            }>;
+        }>>;
+        location: StructType<{
+            filename: StringType;
+            line: IntegerType;
+            column: IntegerType;
+        }>;
+        name: StringType;
+        arguments: ArrayType<import("./types.js").RecursiveTypeMarker>;
+    }>;
+}>>;
+//# sourceMappingURL=ir.d.ts.map