pareto 0.80.74 → 0.80.76

package/dist/modules/typescript_light/schemas/typescript_light/schema.d.ts

@@ -1,257 +1,38 @@
 import * as p_ from 'pareto-core/schema';
-import * as p_di from 'pareto-core/schema';
-export type Directory = {
-    'content': ['files', p_.Dictionary<Source_File>] | ['directories', p_.Dictionary<Directory>] | ['mixed', p_.Dictionary<Node>];
-};
-export type Node = ['file', Source_File] | ['directory', Directory];
-export type Source_File = {
-    'statements': Statements_;
-};
-export type Block_ = Statements_;
-export declare namespace Statements_ {
-    namespace L {
-        type block = Block_;
-        namespace export_ {
-            namespace type_ {
-                namespace named_exports {
-                    namespace specifiers {
-                        namespace L {
-                            type name = Identifier_;
-                            namespace as_ {
-                                type O = Identifier_;
-                            }
-                            type as_ = p_di.Optional_Value<as_.O>;
-                        }
-                        type L = {
-                            readonly 'type only': boolean;
-                            readonly 'name': L.name;
-                            readonly 'as': L.as_;
-                        };
-                    }
-                    type specifiers = p_di.List<specifiers.L>;
-                    namespace from_ {
-                        type O = String_Literal_;
-                    }
-                    type from_ = p_di.Optional_Value<from_.O>;
-                }
-                type named_exports = {
-                    readonly 'specifiers': named_exports.specifiers;
-                    readonly 'from': named_exports.from_;
-                };
-            }
-            type type_ = readonly ['named exports', type_.named_exports];
-        }
-        type export_ = {
-            readonly 'type': export_.type_;
-        };
-        type expression = Expression_;
-        namespace import_ {
-            namespace type_ {
-                type default_ = Identifier_;
-                type namespace = Identifier_;
-                namespace named {
-                    namespace specifiers {
-                        namespace L {
-                            type name = Identifier_;
-                            namespace as_ {
-                                type O = Identifier_;
-                            }
-                            type as_ = p_di.Optional_Value<as_.O>;
-                        }
-                        type L = {
-                            readonly 'name': L.name;
-                            readonly 'as': L.as_;
-                        };
-                    }
-                    type specifiers = p_di.List<specifiers.L>;
-                }
-                type named = {
-                    readonly 'specifiers': named.specifiers;
-                };
-            }
-            type type_ = readonly ['default', type_.default_] | readonly ['namespace', type_.namespace] | readonly ['named', type_.named];
-            type from_ = String_Literal_;
-        }
-        type import_ = {
-            readonly 'type': import_.type_;
-            readonly 'from': import_.from_;
-        };
-        namespace module_declaration {
-            type export_ = boolean;
-            type name = Identifier_;
-            type block = Block_;
-        }
-        type module_declaration = {
-            readonly 'export': module_declaration.export_;
-            readonly 'name': module_declaration.name;
-            readonly 'block': module_declaration.block;
-        };
-        namespace return_ {
-            type O = Expression_;
-        }
-        type return_ = p_di.Optional_Value<return_.O>;
-        namespace switch_ {
-            type expression = Expression_;
-            namespace clauses {
-                namespace L {
-                    namespace type_ {
-                        type case_ = Expression_;
-                        type default_ = null;
-                    }
-                    type type_ = readonly ['case', type_.case_] | readonly ['default', type_.default_];
-                    type statements = Statements_;
-                }
-                type L = {
-                    readonly 'type': L.type_;
-                    readonly 'statements': L.statements;
-                };
-            }
-            type clauses = p_di.List<clauses.L>;
-        }
-        type switch_ = {
-            readonly 'expression': switch_.expression;
-            readonly 'clauses': switch_.clauses;
-        };
-        namespace type_alias_declaration {
-            type export_ = boolean;
-            type name = Identifier_;
-            namespace parameters {
-                type L = Identifier_;
-            }
-            type parameters = p_di.List<parameters.L>;
-            type type_ = Type_;
-        }
-        type type_alias_declaration = {
-            readonly 'export': type_alias_declaration.export_;
-            readonly 'name': type_alias_declaration.name;
-            readonly 'parameters': type_alias_declaration.parameters;
-            readonly 'type': type_alias_declaration.type_;
-        };
-        namespace variable {
-            type export_ = boolean;
-            type const_ = boolean;
-            type name = Identifier_;
-            namespace type_ {
-                type O = Type_;
-            }
-            type type_ = p_di.Optional_Value<type_.O>;
-            namespace expression {
-                type O = Expression_;
-            }
-            type expression = p_di.Optional_Value<expression.O>;
-        }
-        type variable = {
-            readonly 'export': variable.export_;
-            readonly 'const': variable.const_;
-            readonly 'name': variable.name;
-            readonly 'type': variable.type_;
-            readonly 'expression': variable.expression;
-        };
-    }
-    type L = readonly ['empty line', null] | readonly ['block', L.block] | readonly ['export', L.export_] | readonly ['expression', L.expression] | readonly ['import', L.import_] | readonly ['line comment', string] | readonly ['module declaration', L.module_declaration] | readonly ['return', L.return_] | readonly ['switch', L.switch_] | readonly ['type alias declaration', L.type_alias_declaration] | readonly ['variable', L.variable];
+type Block_ = Statements_;
+declare namespace Source_File_ {
+    type statements = Statements_;
 }
-export type Statements_ = p_di.List<Statements_.L>;
-export declare namespace Type_ {
-    type boolean_ = null;
-    namespace function_ {
-        namespace type_parameters {
-            type L = Type_;
-        }
-        type type_parameters = p_di.List<type_parameters.L>;
-        type parameters = Function_Parameters_;
-        type return_ = Type_;
-    }
-    type function_ = {
-        readonly 'type parameters': function_.type_parameters;
-        readonly 'parameters': function_.parameters;
-        readonly 'return': function_.return_;
-    };
-    type literal_type = String_Literal_;
-    type never_ = null;
-    type null_ = null;
-    type number_ = null;
-    type string_ = null;
-    namespace tuple {
-        type readonly = boolean;
-        namespace elements {
-            type L = Type_;
-        }
-        type elements = p_di.List<elements.L>;
-    }
-    type tuple = {
-        readonly 'readonly': tuple.readonly;
-        readonly 'elements': tuple.elements;
-    };
-    namespace type_literal {
-        namespace properties {
-            namespace L {
-                namespace key {
-                    type identifier = Identifier_;
-                    type string_literal = String_Literal_;
-                }
-                type key = readonly ['identifier', key.identifier] | readonly ['string literal', key.string_literal];
-                type readonly = boolean;
-                type type_ = Type_;
-            }
-            type L = {
-                readonly 'key': L.key;
-                readonly 'readonly': L.readonly;
-                readonly 'type': L.type_;
-            };
-        }
-        type properties = p_di.List<properties.L>;
-    }
-    type type_literal = {
-        readonly 'properties': type_literal.properties;
-    };
-    namespace type_reference {
-        type start = Identifier_;
-        namespace tail {
-            type L = Identifier_;
+type Source_File_ = {
+    readonly 'statements': Source_File_.statements;
+};
+declare namespace Directory_ {
+    namespace content {
+        namespace directories {
+            type D = Directory_;
         }
-        type tail = p_di.List<tail.L>;
-        namespace type_arguments {
-            type L = Type_;
+        type directories = p_.Dictionary<directories.D>;
+        namespace files {
+            type D = Source_File_;
         }
-        type type_arguments = p_di.List<type_arguments.L>;
-    }
-    type type_reference = {
-        readonly 'start': type_reference.start;
-        readonly 'tail': type_reference.tail;
-        readonly 'type arguments': type_reference.type_arguments;
-    };
-    namespace union {
-        type L = Type_;
-    }
-    type union = p_di.List<union.L>;
-    type void_ = null;
-}
-export type Type_ = readonly ['boolean', Type_.boolean_] | readonly ['function', Type_.function_] | readonly ['literal type', Type_.literal_type] | readonly ['never', Type_.never_] | readonly ['null', Type_.null_] | readonly ['number', Type_.number_] | readonly ['string', Type_.string_] | readonly ['tuple', Type_.tuple] | readonly ['type literal', Type_.type_literal] | readonly ['type reference', Type_.type_reference] | readonly ['union', Type_.union] | readonly ['void', Type_.void_];
-export declare namespace Function_Parameters_ {
-    namespace L {
-        type name = Identifier_;
-        namespace type_ {
-            type O = Type_;
+        type files = p_.Dictionary<files.D>;
+        namespace mixed {
+            type D = Node_;
         }
-        type type_ = p_di.Optional_Value<type_.O>;
+        type mixed = p_.Dictionary<mixed.D>;
     }
-    type L = {
-        readonly 'name': L.name;
-        readonly 'type': L.type_;
-    };
+    type content = readonly ['directories', content.directories] | readonly ['files', content.files] | readonly ['mixed', content.mixed];
 }
-export type Function_Parameters_ = p_di.List<Function_Parameters_.L>;
-export declare namespace Expression_ {
+type Directory_ = {
+    readonly 'content': Directory_.content;
+};
+declare namespace Expression_ {
     namespace array_literal {
         type L = Expression_;
     }
-    type array_literal = p_di.List<array_literal.L>;
+    type array_literal = p_.List<array_literal.L>;
     namespace arrow_function {
-        type parameters = Function_Parameters_;
-        namespace return_type {
-            type O = Type_;
-        }
-        type return_type = p_di.Optional_Value<return_type.O>;
+        type declaration = Function_Declaration_;
         namespace body {
             type block = Block_;
             type expression = Expression_;
@@ -259,8 +40,7 @@ export declare namespace Expression_ {
         type body = readonly ['block', body.block] | readonly ['expression', body.expression];
     }
     type arrow_function = {
-        readonly 'parameters': arrow_function.parameters;
-        readonly 'return type': arrow_function.return_type;
+        readonly 'declaration': arrow_function.declaration;
         readonly 'body': arrow_function.body;
     };
     namespace assignment {
@@ -273,28 +53,28 @@ export declare namespace Expression_ {
     };
     namespace call {
         type function_selection = Expression_;
+        type arguments_on_own_line = boolean;
         namespace arguments_ {
             type L = Expression_;
         }
-        type arguments_ = p_di.List<arguments_.L>;
+        type arguments_ = p_.List<arguments_.L>;
     }
     type call = {
         readonly 'function selection': call.function_selection;
+        readonly 'arguments on own line': call.arguments_on_own_line;
         readonly 'arguments': call.arguments_;
     };
     namespace compare {
         type left = Expression_;
         namespace operator {
-            type loosely_equal = null;
             type strictly_equal = null;
-            type loosely_not_equal = null;
             type strictly_not_equal = null;
             type smaller_than = null;
             type smaller_than_or_equal = null;
             type greater_than = null;
             type greater_than_or_equal = null;
         }
-        type operator = readonly ['loosely equal', operator.loosely_equal] | readonly ['strictly equal', operator.strictly_equal] | readonly ['loosely not equal', operator.loosely_not_equal] | readonly ['strictly not equal', operator.strictly_not_equal] | readonly ['smaller than', operator.smaller_than] | readonly ['smaller than or equal', operator.smaller_than_or_equal] | readonly ['greater than', operator.greater_than] | readonly ['greater than or equal', operator.greater_than_or_equal];
+        type operator = readonly ['strictly equal', operator.strictly_equal] | readonly ['strictly not equal', operator.strictly_not_equal] | readonly ['smaller than', operator.smaller_than] | readonly ['smaller than or equal', operator.smaller_than_or_equal] | readonly ['greater than', operator.greater_than] | readonly ['greater than or equal', operator.greater_than_or_equal];
         type right = Expression_;
     }
     type compare = {
@@ -339,7 +119,7 @@ export declare namespace Expression_ {
                 readonly 'value': L.value;
             };
         }
-        type properties = p_di.List<properties.L>;
+        type properties = p_.List<properties.L>;
     }
     type object_literal = {
         readonly 'properties': object_literal.properties;
@@ -368,8 +148,198 @@ export declare namespace Expression_ {
         readonly 'operand': unary_operation.operand;
     };
 }
-export type Expression_ = readonly ['array literal', Expression_.array_literal] | readonly ['arrow function', Expression_.arrow_function] | readonly ['assignment', Expression_.assignment] | readonly ['call', Expression_.call] | readonly ['compare', Expression_.compare] | readonly ['conditional', Expression_.conditional] | readonly ['element access', Expression_.element_access] | readonly ['identifier', Expression_.identifier] | readonly ['false', Expression_.false_] | readonly ['null', Expression_.null_] | readonly ['number literal', Expression_.number_literal] | readonly ['object literal', Expression_.object_literal] | readonly ['parenthesized', Expression_.parenthesized] | readonly ['property access', Expression_.property_access] | readonly ['string literal', Expression_.string_literal] | readonly ['true', Expression_.true_] | readonly ['unary operation', Expression_.unary_operation];
-export declare namespace String_Literal_ {
+type Expression_ = readonly ['array literal', Expression_.array_literal] | readonly ['arrow function', Expression_.arrow_function] | readonly ['assignment', Expression_.assignment] | readonly ['call', Expression_.call] | readonly ['compare', Expression_.compare] | readonly ['conditional', Expression_.conditional] | readonly ['element access', Expression_.element_access] | readonly ['identifier', Expression_.identifier] | readonly ['false', Expression_.false_] | readonly ['null', Expression_.null_] | readonly ['number literal', Expression_.number_literal] | readonly ['object literal', Expression_.object_literal] | readonly ['parenthesized', Expression_.parenthesized] | readonly ['property access', Expression_.property_access] | readonly ['string literal', Expression_.string_literal] | readonly ['true', Expression_.true_] | readonly ['unary operation', Expression_.unary_operation];
+declare namespace Function_Declaration_ {
+    namespace type_parameters {
+        type L = Type_;
+    }
+    type type_parameters = p_.List<type_parameters.L>;
+    namespace parameters {
+        namespace L {
+            type name = Identifier_;
+            namespace type_ {
+                type O = Type_;
+            }
+            type type_ = p_.Optional_Value<type_.O>;
+        }
+        type L = {
+            readonly 'name': L.name;
+            readonly 'type': L.type_;
+        };
+    }
+    type parameters = p_.List<parameters.L>;
+    namespace return_type {
+        type O = Type_;
+    }
+    type return_type = p_.Optional_Value<return_type.O>;
+}
+type Function_Declaration_ = {
+    readonly 'type parameters': Function_Declaration_.type_parameters;
+    readonly 'parameters': Function_Declaration_.parameters;
+    readonly 'return type': Function_Declaration_.return_type;
+};
+declare namespace Identifier_ {
+    type raw = string;
+    type escaped = string;
+}
+type Identifier_ = readonly ['raw', Identifier_.raw] | readonly ['escaped', Identifier_.escaped];
+declare namespace Node_ {
+    type directory = Directory_;
+    type file = Source_File_;
+}
+type Node_ = readonly ['directory', Node_.directory] | readonly ['file', Node_.file];
+declare namespace Statement_ {
+    type block = Block_;
+    type empty_line = null;
+    namespace export_ {
+        namespace type_ {
+            namespace named_exports {
+                namespace specifiers {
+                    namespace L {
+                        type type_only = boolean;
+                        type name = Identifier_;
+                        namespace as_ {
+                            type O = Identifier_;
+                        }
+                        type as_ = p_.Optional_Value<as_.O>;
+                    }
+                    type L = {
+                        readonly 'type only': L.type_only;
+                        readonly 'name': L.name;
+                        readonly 'as': L.as_;
+                    };
+                }
+                type specifiers = p_.List<specifiers.L>;
+                namespace from_ {
+                    type O = String_Literal_;
+                }
+                type from_ = p_.Optional_Value<from_.O>;
+            }
+            type named_exports = {
+                readonly 'specifiers': named_exports.specifiers;
+                readonly 'from': named_exports.from_;
+            };
+        }
+        type type_ = readonly ['named exports', type_.named_exports];
+    }
+    type export_ = {
+        readonly 'type': export_.type_;
+    };
+    type expression = Expression_;
+    namespace import_ {
+        namespace type_ {
+            type default_ = Identifier_;
+            type namespace = Identifier_;
+            namespace named {
+                namespace specifiers {
+                    namespace L {
+                        type name = Identifier_;
+                        namespace as_ {
+                            type O = Identifier_;
+                        }
+                        type as_ = p_.Optional_Value<as_.O>;
+                    }
+                    type L = {
+                        readonly 'name': L.name;
+                        readonly 'as': L.as_;
+                    };
+                }
+                type specifiers = p_.List<specifiers.L>;
+            }
+            type named = {
+                readonly 'specifiers': named.specifiers;
+            };
+        }
+        type type_ = readonly ['default', type_.default_] | readonly ['namespace', type_.namespace] | readonly ['named', type_.named];
+        type from_ = String_Literal_;
+    }
+    type import_ = {
+        readonly 'type': import_.type_;
+        readonly 'from': import_.from_;
+    };
+    type line_comment = string;
+    namespace namespace {
+        type export_ = boolean;
+        type name = Identifier_;
+        type block = Block_;
+    }
+    type namespace = {
+        readonly 'export': namespace.export_;
+        readonly 'name': namespace.name;
+        readonly 'block': namespace.block;
+    };
+    namespace return_ {
+        type O = Expression_;
+    }
+    type return_ = p_.Optional_Value<return_.O>;
+    namespace switch_ {
+        type expression = Expression_;
+        namespace clauses {
+            namespace L {
+                namespace type_ {
+                    type case_ = Expression_;
+                    type default_ = null;
+                }
+                type type_ = readonly ['case', type_.case_] | readonly ['default', type_.default_];
+                namespace body {
+                    type statement = Statement_;
+                    type statements = Statements_;
+                }
+                type body = readonly ['statement', body.statement] | readonly ['statements', body.statements];
+            }
+            type L = {
+                readonly 'type': L.type_;
+                readonly 'body': L.body;
+            };
+        }
+        type clauses = p_.List<clauses.L>;
+    }
+    type switch_ = {
+        readonly 'expression': switch_.expression;
+        readonly 'clauses': switch_.clauses;
+    };
+    namespace type_alias_declaration {
+        type export_ = boolean;
+        type name = Identifier_;
+        namespace parameters {
+            type L = Identifier_;
+        }
+        type parameters = p_.List<parameters.L>;
+        type type_ = Type_;
+    }
+    type type_alias_declaration = {
+        readonly 'export': type_alias_declaration.export_;
+        readonly 'name': type_alias_declaration.name;
+        readonly 'parameters': type_alias_declaration.parameters;
+        readonly 'type': type_alias_declaration.type_;
+    };
+    namespace variable {
+        type export_ = boolean;
+        type const_ = boolean;
+        type name = Identifier_;
+        namespace type_ {
+            type O = Type_;
+        }
+        type type_ = p_.Optional_Value<type_.O>;
+        namespace expression {
+            type O = Expression_;
+        }
+        type expression = p_.Optional_Value<expression.O>;
+    }
+    type variable = {
+        readonly 'export': variable.export_;
+        readonly 'const': variable.const_;
+        readonly 'name': variable.name;
+        readonly 'type': variable.type_;
+        readonly 'expression': variable.expression;
+    };
+}
+type Statement_ = readonly ['block', Statement_.block] | readonly ['empty line', Statement_.empty_line] | readonly ['export', Statement_.export_] | readonly ['expression', Statement_.expression] | readonly ['import', Statement_.import_] | readonly ['line comment', Statement_.line_comment] | readonly ['namespace', Statement_.namespace] | readonly ['return', Statement_.return_] | readonly ['switch', Statement_.switch_] | readonly ['type alias declaration', Statement_.type_alias_declaration] | readonly ['variable', Statement_.variable];
+declare namespace Statements_ {
+    type L = Statement_;
+}
+type Statements_ = p_.List<Statements_.L>;
+declare namespace String_Literal_ {
     namespace delimiter {
         type quote = null;
         type apostrophe = null;
@@ -377,14 +347,78 @@ export declare namespace String_Literal_ {
     type delimiter = readonly ['quote', delimiter.quote] | readonly ['apostrophe', delimiter.apostrophe];
     type value = string;
 }
-export type String_Literal_ = {
+type String_Literal_ = {
     readonly 'delimiter': String_Literal_.delimiter;
     readonly 'value': String_Literal_.value;
 };
-export declare namespace Identifier_ {
-    type value = string;
+declare namespace Type_ {
+    type boolean_ = null;
+    namespace function_ {
+        type declaration = Function_Declaration_;
+    }
+    type function_ = {
+        readonly 'declaration': function_.declaration;
+    };
+    type literal_type = String_Literal_;
+    type never_ = null;
+    type null_ = null;
+    type number_ = null;
+    type string_ = null;
+    namespace tuple {
+        type readonly = boolean;
+        namespace elements {
+            type L = Type_;
+        }
+        type elements = p_.List<elements.L>;
+    }
+    type tuple = {
+        readonly 'readonly': tuple.readonly;
+        readonly 'elements': tuple.elements;
+    };
+    namespace type_literal {
+        namespace properties {
+            namespace L {
+                namespace key {
+                    type identifier = Identifier_;
+                    type string_literal = String_Literal_;
+                }
+                type key = readonly ['identifier', key.identifier] | readonly ['string literal', key.string_literal];
+                type readonly = boolean;
+                type type_ = Type_;
+            }
+            type L = {
+                readonly 'key': L.key;
+                readonly 'readonly': L.readonly;
+                readonly 'type': L.type_;
+            };
+        }
+        type properties = p_.List<properties.L>;
+    }
+    type type_literal = {
+        readonly 'properties': type_literal.properties;
+    };
+    namespace type_reference {
+        type start = Identifier_;
+        namespace tail {
+            type L = Identifier_;
+        }
+        type tail = p_.List<tail.L>;
+        namespace type_arguments {
+            type L = Type_;
+        }
+        type type_arguments = p_.List<type_arguments.L>;
+    }
+    type type_reference = {
+        readonly 'start': type_reference.start;
+        readonly 'tail': type_reference.tail;
+        readonly 'type arguments': type_reference.type_arguments;
+    };
+    type undefined_ = null;
+    namespace union {
+        type L = Type_;
+    }
+    type union = p_.List<union.L>;
+    type void_ = null;
 }
-export type Identifier_ = {
-    readonly 'value': Identifier_.value;
-};
-export type { Block_ as Block, Statements_ as Statements, Type_ as Type, Function_Parameters_ as Function_Parameters, Expression_ as Expression, String_Literal_ as String_Literal, Identifier_ as Identifier, };
+type Type_ = readonly ['boolean', Type_.boolean_] | readonly ['function', Type_.function_] | readonly ['literal type', Type_.literal_type] | readonly ['never', Type_.never_] | readonly ['null', Type_.null_] | readonly ['number', Type_.number_] | readonly ['string', Type_.string_] | readonly ['tuple', Type_.tuple] | readonly ['type literal', Type_.type_literal] | readonly ['type reference', Type_.type_reference] | readonly ['undefined', Type_.undefined_] | readonly ['union', Type_.union] | readonly ['void', Type_.void_];
+export { type Block_ as Block, type Source_File_ as Source_File, type Directory_ as Directory, type Expression_ as Expression, type Function_Declaration_ as Function_Declaration, type Identifier_ as Identifier, type Node_ as Node, type Statement_ as Statement, type Statements_ as Statements, type String_Literal_ as String_Literal, type Type_ as Type, };

package/dist/modules/typescript_light/schemas/typescript_light/schema.js

@@ -1,4 +1,4 @@
 import * as p_ from 'pareto-core/schema';
-import * as p_i from 'pareto-core/__internal/Abort';
-import * as p_di from 'pareto-core/schema';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvdHlwZXNjcmlwdF9saWdodC9zY2hlbWFzL3R5cGVzY3JpcHRfbGlnaHQvc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFFeEMsT0FBTyxLQUFLLEdBQUcsTUFBTSw4QkFBOEIsQ0FBQTtBQUNuRCxPQUFPLEtBQUssSUFBSSxNQUFNLG9CQUFvQixDQUFBIn0=
+// exported root types
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvdHlwZXNjcmlwdF9saWdodC9zY2hlbWFzL3R5cGVzY3JpcHRfbGlnaHQvc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFneUJ4QyxzQkFBc0I7QUFDdEIsT0FBTyxFQVlOLENBQUEifQ==

package/dist/modules/typescript_light/schemas/{primitives → typescript_light}/serializers.d.ts

@@ -1,13 +1,12 @@
 import * as p_ from 'pareto-core/serializer';
-import type * as s_in from "../typescript_light/schema.js";
-import type * as s_in2 from "./schema.js";
+import type * as s_in from "./schema.js";
 declare namespace declarations {
-    type Escaped_Text = p_.Serializer<s_in2.Text>;
-    type Apostrophed_Text = p_.Serializer<s_in2.Text>;
-    type Backticked_Text = p_.Serializer<s_in2.Text>;
-    type Quoted_Text = p_.Serializer<s_in2.Text>;
-    type Decimal = p_.Serializer<s_in2.Number>;
-    type Float = p_.Serializer<s_in2.Number>;
+    type Escaped_Text = p_.Serializer<string>;
+    type Apostrophed_Text = p_.Serializer<string>;
+    type Backticked_Text = p_.Serializer<string>;
+    type Quoted_Text = p_.Serializer<string>;
+    type Decimal = p_.Serializer<number>;
+    type Float = p_.Serializer<number>;
     type Identifier = p_.Serializer<s_in.Identifier>;
 }
 export declare const Escaped_Text: declarations.Escaped_Text;