astn 0.113.30 → 0.113.32

package/dist/interface/generated/pareto/schemas/authoring_target/data.d.ts

@@ -0,0 +1,102 @@
+import * as _pi from "pareto-core-interface";
+export declare namespace Value_ {
+    namespace metadata {
+        namespace comments {
+            type L = string;
+        }
+        type comments = _pi.List<comments.L>;
+    }
+    type metadata = {
+        readonly 'comments': metadata.comments;
+    };
+    namespace data {
+        type missing = null;
+        namespace include {
+            type path = string;
+        }
+        type include = {
+            readonly 'path': include.path;
+        };
+        namespace concrete {
+            namespace _type {
+                namespace dictionary {
+                    namespace D {
+                        type O = Value_;
+                    }
+                    type D = _pi.Optional_Value<D.O>;
+                }
+                type dictionary = _pi.Dictionary<dictionary.D>;
+                namespace group {
+                    namespace concise {
+                        type L = Value_;
+                    }
+                    type concise = _pi.List<concise.L>;
+                    namespace verbose {
+                        namespace D {
+                            type O = Value_;
+                        }
+                        type D = _pi.Optional_Value<D.O>;
+                    }
+                    type verbose = _pi.Dictionary<verbose.D>;
+                }
+                type group = readonly ['concise', group.concise] | readonly ['verbose', group.verbose];
+                namespace list {
+                    type L = Value_;
+                }
+                type list = _pi.List<list.L>;
+                type nothing = null;
+                namespace optional {
+                    type not_set = null;
+                    type _set = Value_;
+                }
+                type optional = readonly ['not set', optional.not_set] | readonly ['set', optional._set];
+                namespace state_group {
+                    type missing_data = null;
+                    namespace _set {
+                        type state = string;
+                        type value = Value_;
+                    }
+                    type _set = {
+                        readonly 'state': _set.state;
+                        readonly 'value': _set.value;
+                    };
+                }
+                type state_group = readonly ['missing data', state_group.missing_data] | readonly ['set', state_group._set];
+                namespace text {
+                    type value = string;
+                    namespace delimiter {
+                        type none = null;
+                        type quote = null;
+                        type backtick = null;
+                    }
+                    type delimiter = readonly ['none', delimiter.none] | readonly ['quote', delimiter.quote] | readonly ['backtick', delimiter.backtick];
+                }
+                type text = {
+                    readonly 'value': text.value;
+                    readonly 'delimiter': text.delimiter;
+                };
+            }
+            type _type = readonly ['dictionary', _type.dictionary] | readonly ['group', _type.group] | readonly ['list', _type.list] | readonly ['nothing', _type.nothing] | readonly ['optional', _type.optional] | readonly ['state group', _type.state_group] | readonly ['text', _type.text];
+        }
+        type concrete = {
+            readonly 'type': concrete._type;
+        };
+    }
+    type data = readonly ['missing', data.missing] | readonly ['include', data.include] | readonly ['concrete', data.concrete];
+}
+export type Value_ = {
+    readonly 'metadata': Value_.metadata;
+    readonly 'data': Value_.data;
+};
+export declare namespace Document_ {
+    namespace header {
+        type O = Value_;
+    }
+    type header = _pi.Optional_Value<header.O>;
+    type content = Value_;
+}
+export type Document_ = {
+    readonly 'header': Document_.header;
+    readonly 'content': Document_.content;
+};
+export { Value_ as Value, Document_ as Document, };

package/dist/interface/generated/pareto/schemas/authoring_target/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2F1dGhvcmluZ190YXJnZXQvZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/authoring_target/migrate_boilerplate.d.ts

@@ -1,5 +1,5 @@
-import * as i_out from "./data_types/target";
-import * as i_in from "./data_types/source";
+import * as i_out from "./data";
+import * as i_in from "./data";
 export declare namespace Value_ {
     type I = i_in.Value;
     type O = i_out.Value;

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/data.d.ts

@@ -0,0 +1,116 @@
+import * as _pi from "pareto-core-interface";
+import * as i__imports_token from "../token/data";
+export declare namespace Lexer_Error_ {
+    namespace unexpected_control_character {
+        type character = number;
+        type location = i__imports_token.Location;
+    }
+    type unexpected_control_character = {
+        readonly 'character': unexpected_control_character.character;
+        readonly 'location': unexpected_control_character.location;
+    };
+    namespace missing_character_after_escape {
+        type character = number;
+        type location = i__imports_token.Location;
+    }
+    type missing_character_after_escape = {
+        readonly 'character': missing_character_after_escape.character;
+        readonly 'location': missing_character_after_escape.location;
+    };
+    namespace unexpected_end_of_line_in_delimited_text {
+        type range = i__imports_token.Range;
+    }
+    type unexpected_end_of_line_in_delimited_text = {
+        readonly 'range': unexpected_end_of_line_in_delimited_text.range;
+    };
+    namespace unexpected_character {
+        type character = number;
+        type location = i__imports_token.Location;
+    }
+    type unexpected_character = {
+        readonly 'character': unexpected_character.character;
+        readonly 'location': unexpected_character.location;
+    };
+    namespace unterminated_text {
+        type range = i__imports_token.Range;
+    }
+    type unterminated_text = {
+        readonly 'range': unterminated_text.range;
+    };
+    namespace unterminated_block_comment {
+        type range = i__imports_token.Range;
+    }
+    type unterminated_block_comment = {
+        readonly 'range': unterminated_block_comment.range;
+    };
+    namespace unterminated_unicode_escape_sequence {
+        type range = i__imports_token.Range;
+    }
+    type unterminated_unicode_escape_sequence = {
+        readonly 'range': unterminated_unicode_escape_sequence.range;
+    };
+    namespace invalid_unicode_escape_sequence {
+        type range = i__imports_token.Range;
+    }
+    type invalid_unicode_escape_sequence = {
+        readonly 'range': invalid_unicode_escape_sequence.range;
+    };
+    namespace unknown_escape_character {
+        type range = i__imports_token.Range;
+    }
+    type unknown_escape_character = {
+        readonly 'range': unknown_escape_character.range;
+    };
+    namespace dangling_slash {
+        type location = i__imports_token.Location;
+    }
+    type dangling_slash = {
+        readonly 'location': dangling_slash.location;
+    };
+}
+export type Lexer_Error_ = readonly ['unexpected control character', Lexer_Error_.unexpected_control_character] | readonly ['missing character after escape', Lexer_Error_.missing_character_after_escape] | readonly ['unexpected end of line in delimited text', Lexer_Error_.unexpected_end_of_line_in_delimited_text] | readonly ['unexpected character', Lexer_Error_.unexpected_character] | readonly ['unterminated text', Lexer_Error_.unterminated_text] | readonly ['unterminated block comment', Lexer_Error_.unterminated_block_comment] | readonly ['unterminated unicode escape sequence', Lexer_Error_.unterminated_unicode_escape_sequence] | readonly ['invalid unicode escape sequence', Lexer_Error_.invalid_unicode_escape_sequence] | readonly ['unknown escape character', Lexer_Error_.unknown_escape_character] | readonly ['dangling slash', Lexer_Error_.dangling_slash];
+export declare namespace Expected_ {
+    type a_text_value = null;
+    type any_value = null;
+    type $ex_ = null;
+    type $gt_ = null;
+    type $cc_ = null;
+    type $at_ = null;
+    type $cm_ = null;
+    type $cl_ = null;
+    type $pc_ = null;
+    type $bc_ = null;
+    type $ha_ = null;
+}
+export type Expected_ = readonly ['a text value', Expected_.a_text_value] | readonly ['any value', Expected_.any_value] | readonly ['!', Expected_.$ex_] | readonly ['>', Expected_.$gt_] | readonly ['}', Expected_.$cc_] | readonly ['@', Expected_.$at_] | readonly [',', Expected_.$cm_] | readonly [':', Expected_.$cl_] | readonly [')', Expected_.$pc_] | readonly [']', Expected_.$bc_] | readonly ['#', Expected_.$ha_];
+export declare namespace Parser_Error_ {
+    namespace expected {
+        type L = Expected_;
+    }
+    type expected = _pi.List<expected.L>;
+    namespace cause {
+        type missing_token = null;
+        namespace unexpected_token {
+            type found = i__imports_token.Annotated_Token;
+        }
+        type unexpected_token = {
+            readonly 'found': unexpected_token.found;
+        };
+    }
+    type cause = readonly ['missing token', cause.missing_token] | readonly ['unexpected token', cause.unexpected_token];
+}
+export type Parser_Error_ = {
+    readonly 'expected': Parser_Error_.expected;
+    readonly 'cause': Parser_Error_.cause;
+};
+export declare namespace Error_ {
+    namespace _type {
+        type lexer = Lexer_Error_;
+        type parser = Parser_Error_;
+    }
+    type _type = readonly ['lexer', _type.lexer] | readonly ['parser', _type.parser];
+}
+export type Error_ = {
+    readonly 'type': Error_._type;
+};
+export { Lexer_Error_ as Lexer_Error, Expected_ as Expected, Parser_Error_ as Parser_Error, Error_ as Error, };

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2Rlc2VyaWFsaXplX3BhcnNlX3RyZWUvZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/deserialize_parse_tree/migrate_boilerplate.d.ts

@@ -0,0 +1,31 @@
+import * as i_out from "./data";
+import * as i_in from "./data";
+export declare namespace Lexer_Error_ {
+    type I = i_in.Lexer_Error;
+    type O = i_out.Lexer_Error;
+    namespace P {
+    }
+}
+export type Lexer_Error_ = ($$_: Lexer_Error_.I) => Lexer_Error_.O;
+export declare namespace Expected_ {
+    type I = i_in.Expected;
+    type O = i_out.Expected;
+    namespace P {
+    }
+}
+export type Expected_ = ($$_: Expected_.I) => Expected_.O;
+export declare namespace Parser_Error_ {
+    type I = i_in.Parser_Error;
+    type O = i_out.Parser_Error;
+    namespace P {
+    }
+}
+export type Parser_Error_ = ($$_: Parser_Error_.I) => Parser_Error_.O;
+export declare namespace Error_ {
+    type I = i_in.Error;
+    type O = i_out.Error;
+    namespace P {
+    }
+}
+export type Error_ = ($$_: Error_.I) => Error_.O;
+export { Lexer_Error_ as Lexer_Error, Expected_ as Expected, Parser_Error_ as Parser_Error, Error_ as Error, };

package/dist/interface/generated/pareto/schemas/{authoring_parse_result → deserialize_parse_tree}/migrate_boilerplate.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlncmF0ZV9ib2lsZXJwbGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2F1dGhvcmluZ19wYXJzZV9yZXN1bHQvbWlncmF0ZV9ib2lsZXJwbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlncmF0ZV9ib2lsZXJwbGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2Rlc2VyaWFsaXplX3BhcnNlX3RyZWUvbWlncmF0ZV9ib2lsZXJwbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/ide/{data_types/source.d.ts → data.d.ts}

@@ -1,8 +1,15 @@
 import * as _pi from "pareto-core-interface";
-import * as i_imports_token from "../../token/data_types/source";
+export declare namespace Relative_Location_ {
+    type line = number;
+    type column = number;
+}
+export type Relative_Location_ = {
+    readonly 'line': Relative_Location_.line;
+    readonly 'column': Relative_Location_.column;
+};
 export declare namespace Relative_Range_ {
-    type start = i_imports_token.Relative_Location;
-    type end = i_imports_token.Relative_Location;
+    type start = Relative_Location_;
+    type end = Relative_Location_;
 }
 export type Relative_Range_ = {
     readonly 'start': Relative_Range_.start;
@@ -11,7 +18,7 @@ export type Relative_Range_ = {
 export declare namespace Text_Edits_ {
     namespace L {
         namespace insert {
-            type location = i_imports_token.Relative_Location;
+            type location = Relative_Location_;
             type text = string;
         }
         type insert = {
@@ -40,4 +47,4 @@ export declare namespace Key_Value_Pairs_To_Be_Sorted_ {
     type D = string;
 }
 export type Key_Value_Pairs_To_Be_Sorted_ = _pi.Dictionary<Key_Value_Pairs_To_Be_Sorted_.D>;
-export { Relative_Range_ as Relative_Range, Text_Edits_ as Text_Edits, Key_Value_Pairs_To_Be_Sorted_ as Key_Value_Pairs_To_Be_Sorted, };
+export { Relative_Location_ as Relative_Location, Relative_Range_ as Relative_Range, Text_Edits_ as Text_Edits, Key_Value_Pairs_To_Be_Sorted_ as Key_Value_Pairs_To_Be_Sorted, };

package/dist/interface/generated/pareto/schemas/ide/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2lkZS9kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/interface/generated/pareto/schemas/ide/migrate_boilerplate.d.ts

@@ -1,5 +1,12 @@
-import * as i_out from "./data_types/target";
-import * as i_in from "./data_types/source";
+import * as i_out from "./data";
+import * as i_in from "./data";
+export declare namespace Relative_Location_ {
+    type I = i_in.Relative_Location;
+    type O = i_out.Relative_Location;
+    namespace P {
+    }
+}
+export type Relative_Location_ = ($$_: Relative_Location_.I) => Relative_Location_.O;
 export declare namespace Relative_Range_ {
     type I = i_in.Relative_Range;
     type O = i_out.Relative_Range;
@@ -21,4 +28,4 @@ export declare namespace Key_Value_Pairs_To_Be_Sorted_ {
     }
 }
 export type Key_Value_Pairs_To_Be_Sorted_ = ($$_: Key_Value_Pairs_To_Be_Sorted_.I) => Key_Value_Pairs_To_Be_Sorted_.O;
-export { Relative_Range_ as Relative_Range, Text_Edits_ as Text_Edits, Key_Value_Pairs_To_Be_Sorted_ as Key_Value_Pairs_To_Be_Sorted, };
+export { Relative_Location_ as Relative_Location, Relative_Range_ as Relative_Range, Text_Edits_ as Text_Edits, Key_Value_Pairs_To_Be_Sorted_ as Key_Value_Pairs_To_Be_Sorted, };

package/dist/interface/generated/pareto/schemas/parse_tree/data.d.ts

@@ -0,0 +1,182 @@
+import * as _pi from "pareto-core-interface";
+import * as i__imports_token from "../token/data";
+export declare namespace Structural_Token_ {
+    type trailing_trivia = i__imports_token.Trivia;
+    type range = i__imports_token.Range;
+}
+export type Structural_Token_ = {
+    readonly 'trailing trivia': Structural_Token_.trailing_trivia;
+    readonly 'range': Structural_Token_.range;
+};
+export declare namespace Text_ {
+    type trailing_trivia = i__imports_token.Trivia;
+    type range = i__imports_token.Range;
+    type value = string;
+    type _type = i__imports_token.Text_Type;
+}
+export type Text_ = {
+    readonly 'trailing trivia': Text_.trailing_trivia;
+    readonly 'range': Text_.range;
+    readonly 'value': Text_.value;
+    readonly 'type': Text_._type;
+};
+export declare namespace Key_Value_Pairs_ {
+    namespace L {
+        type key = Text_;
+        namespace value {
+            namespace O {
+                type $cl_ = Structural_Token_;
+                type value = Value_;
+            }
+            type O = {
+                readonly ':': O.$cl_;
+                readonly 'value': O.value;
+            };
+        }
+        type value = _pi.Optional_Value<value.O>;
+    }
+    type L = {
+        readonly 'key': L.key;
+        readonly 'value': L.value;
+    };
+}
+export type Key_Value_Pairs_ = _pi.List<Key_Value_Pairs_.L>;
+export declare namespace Elements_ {
+    namespace L {
+        type value = Value_;
+    }
+    type L = {
+        readonly 'value': L.value;
+    };
+}
+export type Elements_ = _pi.List<Elements_.L>;
+export declare namespace Value_ {
+    namespace _type {
+        namespace concrete {
+            namespace dictionary {
+                type $co_ = Structural_Token_;
+                type entries = Key_Value_Pairs_;
+                type $cc_ = Structural_Token_;
+            }
+            type dictionary = {
+                readonly '{': dictionary.$co_;
+                readonly 'entries': dictionary.entries;
+                readonly '}': dictionary.$cc_;
+            };
+            namespace group {
+                namespace concise {
+                    type $st_ = Structural_Token_;
+                    type elements = Elements_;
+                    type $gt_ = Structural_Token_;
+                }
+                type concise = {
+                    readonly '<': concise.$st_;
+                    readonly 'elements': concise.elements;
+                    readonly '>': concise.$gt_;
+                };
+                namespace verbose {
+                    type $po_ = Structural_Token_;
+                    type entries = Key_Value_Pairs_;
+                    type $pc_ = Structural_Token_;
+                }
+                type verbose = {
+                    readonly '(': verbose.$po_;
+                    readonly 'entries': verbose.entries;
+                    readonly ')': verbose.$pc_;
+                };
+            }
+            type group = readonly ['concise', group.concise] | readonly ['verbose', group.verbose];
+            namespace list {
+                type $bo_ = Structural_Token_;
+                type elements = Elements_;
+                type $bc_ = Structural_Token_;
+            }
+            type list = {
+                readonly '[': list.$bo_;
+                readonly 'elements': list.elements;
+                readonly ']': list.$bc_;
+            };
+            namespace nothing {
+                type $ti_ = Structural_Token_;
+            }
+            type nothing = {
+                readonly '~': nothing.$ti_;
+            };
+            namespace optional {
+                namespace _set {
+                    type $sr_ = Structural_Token_;
+                    type value = Value_;
+                }
+                type _set = {
+                    readonly '*': _set.$sr_;
+                    readonly 'value': _set.value;
+                };
+            }
+            type optional = readonly ['set', optional._set];
+            namespace state_group {
+                type $vb_ = Structural_Token_;
+                namespace status {
+                    namespace missing_data {
+                        type $ha_ = Structural_Token_;
+                    }
+                    type missing_data = {
+                        readonly '#': missing_data.$ha_;
+                    };
+                    namespace _set {
+                        type state = Text_;
+                        type value = Value_;
+                    }
+                    type _set = {
+                        readonly 'state': _set.state;
+                        readonly 'value': _set.value;
+                    };
+                }
+                type status = readonly ['missing data', status.missing_data] | readonly ['set', status._set];
+            }
+            type state_group = {
+                readonly '|': state_group.$vb_;
+                readonly 'status': state_group.status;
+            };
+            type text = Text_;
+        }
+        type concrete = readonly ['dictionary', concrete.dictionary] | readonly ['group', concrete.group] | readonly ['list', concrete.list] | readonly ['nothing', concrete.nothing] | readonly ['optional', concrete.optional] | readonly ['state group', concrete.state_group] | readonly ['text', concrete.text];
+        namespace include {
+            type $at_ = Structural_Token_;
+            type path = Text_;
+        }
+        type include = {
+            readonly '@': include.$at_;
+            readonly 'path': include.path;
+        };
+        namespace missing_data {
+            type $ha_ = Structural_Token_;
+        }
+        type missing_data = {
+            readonly '#': missing_data.$ha_;
+        };
+    }
+    type _type = readonly ['concrete', _type.concrete] | readonly ['include', _type.include] | readonly ['missing data', _type.missing_data];
+}
+export type Value_ = {
+    readonly 'type': Value_._type;
+};
+export type Content_ = Value_;
+export declare namespace Document_ {
+    namespace header {
+        namespace O {
+            type $ex_ = Structural_Token_;
+            type value = Value_;
+        }
+        type O = {
+            readonly '!': O.$ex_;
+            readonly 'value': O.value;
+        };
+    }
+    type header = _pi.Optional_Value<header.O>;
+    type content = Content_;
+}
+export type Document_ = {
+    readonly 'header': Document_.header;
+    readonly 'content': Document_.content;
+};
+export { Structural_Token_ as Structural_Token, Text_ as Text, Key_Value_Pairs_ as Key_Value_Pairs, Elements_ as Elements, Value_ as Value, Content_ as Content, Document_ as Document, };

package/dist/interface/generated/pareto/schemas/parse_tree/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL3BhcnNlX3RyZWUvZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/{authoring_parse_tree → parse_tree}/migrate_boilerplate.d.ts

@@ -1,5 +1,5 @@
-import * as i_out from "./data_types/target";
-import * as i_in from "./data_types/source";
+import * as i_out from "./data";
+import * as i_in from "./data";
 export declare namespace Structural_Token_ {
     type I = i_in.Structural_Token;
     type O = i_out.Structural_Token;
@@ -7,13 +7,13 @@ export declare namespace Structural_Token_ {
     }
 }
 export type Structural_Token_ = ($$_: Structural_Token_.I) => Structural_Token_.O;
-export declare namespace String_ {
-    type I = i_in.String;
-    type O = i_out.String;
+export declare namespace Text_ {
+    type I = i_in.Text;
+    type O = i_out.Text;
     namespace P {
     }
 }
-export type String_ = ($$_: String_.I) => String_.O;
+export type Text_ = ($$_: Text_.I) => Text_.O;
 export declare namespace Key_Value_Pairs_ {
     type I = i_in.Key_Value_Pairs;
     type O = i_out.Key_Value_Pairs;
@@ -28,13 +28,6 @@ export declare namespace Elements_ {
     }
 }
 export type Elements_ = ($$_: Elements_.I) => Elements_.O;
-export declare namespace Concrete_Value_ {
-    type I = i_in.Concrete_Value;
-    type O = i_out.Concrete_Value;
-    namespace P {
-    }
-}
-export type Concrete_Value_ = ($$_: Concrete_Value_.I) => Concrete_Value_.O;
 export declare namespace Value_ {
     type I = i_in.Value;
     type O = i_out.Value;
@@ -56,4 +49,4 @@ export declare namespace Document_ {
     }
 }
 export type Document_ = ($$_: Document_.I) => Document_.O;
-export { Structural_Token_ as Structural_Token, String_ as String, Key_Value_Pairs_ as Key_Value_Pairs, Elements_ as Elements, Concrete_Value_ as Concrete_Value, Value_ as Value, Content_ as Content, Document_ as Document, };
+export { Structural_Token_ as Structural_Token, Text_ as Text, Key_Value_Pairs_ as Key_Value_Pairs, Elements_ as Elements, Value_ as Value, Content_ as Content, Document_ as Document, };

package/dist/interface/generated/pareto/schemas/{authoring_parse_tree → parse_tree}/migrate_boilerplate.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlncmF0ZV9ib2lsZXJwbGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL2F1dGhvcmluZ19wYXJzZV90cmVlL21pZ3JhdGVfYm9pbGVycGxhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlncmF0ZV9ib2lsZXJwbGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL3BhcnNlX3RyZWUvbWlncmF0ZV9ib2lsZXJwbGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/sealed_target/{data_types/source.d.ts → data.d.ts}

@@ -8,10 +8,27 @@ export declare namespace Value_ {
         type D = Value_;
     }
     type dictionary = _pi.Dictionary<dictionary.D>;
-    namespace verbose_group {
-        type D = Value_;
+    namespace group {
+        namespace verbose {
+            type D = Value_;
+        }
+        type verbose = _pi.Dictionary<verbose.D>;
+    }
+    type group = readonly ['verbose', group.verbose];
+    type nothing = null;
+    namespace optional {
+        type not_set = null;
+        type _set = Value_;
+    }
+    type optional = readonly ['not set', optional.not_set] | readonly ['set', optional._set];
+    namespace state_group {
+        type state = string;
+        type value = Value_;
     }
-    type verbose_group = _pi.Dictionary<verbose_group.D>;
+    type state_group = {
+        readonly 'state': state_group.state;
+        readonly 'value': state_group.value;
+    };
     namespace text {
         type value = string;
         namespace delimiter {
@@ -25,21 +42,7 @@ export declare namespace Value_ {
         readonly 'value': text.value;
         readonly 'delimiter': text.delimiter;
     };
-    type nothing = null;
-    namespace optional {
-        type not_set = null;
-        type _set = Value_;
-    }
-    type optional = readonly ['not set', optional.not_set] | readonly ['set', optional._set];
-    namespace state {
-        type state = string;
-        type value = Value_;
-    }
-    type state = {
-        readonly 'state': state.state;
-        readonly 'value': state.value;
-    };
 }
-export type Value_ = readonly ['list', Value_.list] | readonly ['dictionary', Value_.dictionary] | readonly ['verbose group', Value_.verbose_group] | readonly ['text', Value_.text] | readonly ['nothing', Value_.nothing] | readonly ['optional', Value_.optional] | readonly ['state', Value_.state];
+export type Value_ = readonly ['list', Value_.list] | readonly ['dictionary', Value_.dictionary] | readonly ['group', Value_.group] | readonly ['nothing', Value_.nothing] | readonly ['optional', Value_.optional] | readonly ['state group', Value_.state_group] | readonly ['text', Value_.text];
 export type Document_ = Value_;
 export { Value_ as Value, Document_ as Document, };

package/dist/interface/generated/pareto/schemas/sealed_target/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcmZhY2UvZ2VuZXJhdGVkL3BhcmV0by9zY2hlbWFzL3NlYWxlZF90YXJnZXQvZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/generated/pareto/schemas/sealed_target/migrate_boilerplate.d.ts

@@ -1,5 +1,5 @@
-import * as i_out from "./data_types/source";
-import * as i_in from "./data_types/source";
+import * as i_out from "./data";
+import * as i_in from "./data";
 export declare namespace Value_ {
     type I = i_in.Value;
     type O = i_out.Value;