pareto 0.76.7 → 0.76.9

package/dist/generated/interface/schemas/schema/migration_boilerplate.d.ts

@@ -22,6 +22,7 @@ export type _T_Reference_To_Property_Constraint = ($$_: _i_in._T_Reference_To_Pr
 export type _T_Relative_Value_Selection = ($$_: _i_in._T_Relative_Value_Selection, $$_p: null) => _i_out._T_Relative_Value_Selection<null>;
 export type _T_Resolve_Logic = ($$_: _i_in._T_Resolve_Logic, $$_p: null) => _i_out._T_Resolve_Logic<null>;
 export type _T_Resolvers = ($$_: _i_in._T_Resolvers, $$_p: null) => _i_out._T_Resolvers<null>;
+export type _T_Schema = ($$_: _i_in._T_Schema, $$_p: null) => _i_out._T_Schema<null>;
 export type _T_Schemas = ($$_: _i_in._T_Schemas, $$_p: null) => _i_out._T_Schemas<null>;
 export type _T_Signature = ($$_: _i_in._T_Signature, $$_p: null) => _i_out._T_Signature<null>;
 export type _T_Signature_Parameters = ($$_: _i_in._T_Signature_Parameters, $$_p: null) => _i_out._T_Signature_Parameters<null>;
@@ -55,6 +56,7 @@ export type Reference_To_Property_Constraint = _T_Reference_To_Property_Constrai
 export type Relative_Value_Selection = _T_Relative_Value_Selection;
 export type Resolve_Logic = _T_Resolve_Logic;
 export type Resolvers = _T_Resolvers;
+export type Schema = _T_Schema;
 export type Schemas = _T_Schemas;
 export type Signature = _T_Signature;
 export type Signature_Parameters = _T_Signature_Parameters;
@@ -308,6 +310,17 @@ export declare namespace _T_Resolvers {
     }
     type RESULT = _i_out._T_Resolvers<null>;
 }
+export declare namespace _T_Schema {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Schema;
+    namespace PARAMS {
+    }
+    namespace RESULT {
+        type annotation = null;
+    }
+    type RESULT = _i_out._T_Schema<null>;
+}
 export declare namespace _T_Schemas {
     namespace CONTEXT {
     }
@@ -671,6 +684,17 @@ export declare namespace Resolvers {
     }
     type RESULT = _i_out._T_Resolvers<null>;
 }
+export declare namespace Schema {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Schema;
+    namespace PARAMS {
+    }
+    namespace RESULT {
+        type annotation = null;
+    }
+    type RESULT = _i_out._T_Schema<null>;
+}
 export declare namespace Schemas {
     namespace CONTEXT {
     }

package/dist/generated/interface/schemas/schema/resolve.d.ts

@@ -305,6 +305,15 @@ export type _T_Resolvers<G_Source> = ($$_: _i_unresolved._T_Resolvers<G_Source>,
         };
     };
 }) => _i_resolved._T_Resolvers;
+export type _T_Schema<G_Source> = ($$_: _i_unresolved._T_Schema<G_Source>, $$_p: {
+    readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
+    readonly 'parameters': {
+        readonly 'lookups': {
+            readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+        };
+        readonly 'values': null;
+    };
+}) => _i_resolved._T_Schema;
 export type _T_Schemas<G_Source> = ($$_: _i_unresolved._T_Schemas<G_Source>, $$_p: {
     readonly 'location 2 string': _i_generic._T_Location_2_String<G_Source>;
     readonly 'parameters': {
@@ -442,6 +451,7 @@ export type Reference_To_Property_Constraint<G_Source> = _T_Reference_To_Propert
 export type Relative_Value_Selection<G_Source> = _T_Relative_Value_Selection<G_Source>;
 export type Resolve_Logic<G_Source> = _T_Resolve_Logic<G_Source>;
 export type Resolvers<G_Source> = _T_Resolvers<G_Source>;
+export type Schema<G_Source> = _T_Schema<G_Source>;
 export type Schemas<G_Source> = _T_Schemas<G_Source>;
 export type Signature<G_Source> = _T_Signature<G_Source>;
 export type Signature_Parameters<G_Source> = _T_Signature_Parameters<G_Source>;
@@ -1933,6 +1943,43 @@ export declare namespace _T_Resolvers {
     }
     type RESULT<G_Source> = _i_resolved._T_Resolvers;
 }
+export declare namespace _T_Schema {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Schema<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<G_Source> = _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Schema;
+}
 export declare namespace _T_Schemas {
     namespace CONTEXT {
         type Source<G_Source> = G_Source;
@@ -3906,6 +3953,43 @@ export declare namespace Resolvers {
     }
     type RESULT<G_Source> = _i_resolved._T_Resolvers;
 }
+export declare namespace Schema {
+    namespace CONTEXT {
+        type Source<G_Source> = G_Source;
+    }
+    type CONTEXT<G_Source> = _i_unresolved._T_Schema<G_Source>;
+    namespace PARAMS {
+        namespace location_2_string {
+            type Source<G_Source> = G_Source;
+        }
+        type location_2_string<G_Source> = _i_generic._T_Location_2_String<G_Source>;
+        namespace parameters {
+            namespace lookups {
+                namespace sibling_schemas {
+                    namespace T {
+                    }
+                    type T<G_Source> = _i_resolved._T_Schemas.D;
+                }
+                type sibling_schemas<G_Source> = _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            }
+            type lookups<G_Source> = {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            namespace values {
+            }
+            type values<G_Source> = null;
+        }
+        type parameters<G_Source> = {
+            readonly 'lookups': {
+                readonly 'sibling schemas': _i_generic._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
+            };
+            readonly 'values': null;
+        };
+    }
+    namespace RESULT {
+    }
+    type RESULT<G_Source> = _i_resolved._T_Schema;
+}
 export declare namespace Schemas {
     namespace CONTEXT {
         type Source<G_Source> = G_Source;

package/dist/generated/interface/schemas/schema/resolved.d.ts

@@ -230,15 +230,13 @@ export type _T_Resolvers = _i_core._T_Ordered_Dictionary<null, {
     readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
     readonly 'type resolver': _T_Node_Resolver;
 }>;
-export type _T_Schemas = _i_core._T_Ordered_Dictionary<null, _i_core._T_State_Group<null, readonly [
-    'schema',
-    {
-        readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-        readonly 'globals': _T_Globals;
-        readonly 'imports': _T_Imports;
-        readonly 'types': _T_Types;
-    }
-] | readonly ['set', _T_Schemas]>>;
+export type _T_Schema = {
+    readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
+    readonly 'globals': _T_Globals;
+    readonly 'imports': _T_Imports;
+    readonly 'types': _T_Types;
+};
+export type _T_Schemas = _i_core._T_Ordered_Dictionary<null, _i_core._T_State_Group<null, readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas]>>;
 export type _T_Signature = {
     readonly 'parameters': _i_core._T_State_Group<null, readonly ['local', _T_Signature_Parameters] | readonly ['same as', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
     readonly 'resolved parameters': _i_core._T_Derived_Reference<null, _T_Signature_Parameters>;
@@ -336,6 +334,7 @@ export type Reference_To_Property_Constraint = _T_Reference_To_Property_Constrai
 export type Relative_Value_Selection = _T_Relative_Value_Selection;
 export type Resolve_Logic = _T_Resolve_Logic;
 export type Resolvers = _T_Resolvers;
+export type Schema = _T_Schema;
 export type Schemas = _T_Schemas;
 export type Signature = _T_Signature;
 export type Signature_Parameters = _T_Signature_Parameters;
@@ -1608,59 +1607,40 @@ export declare namespace _T_Resolvers {
         readonly 'type resolver': _T_Node_Resolver;
     };
 }
+export declare namespace _T_Schema {
+    namespace complexity {
+        namespace SG {
+            namespace constrained {
+            }
+            type constrained = _T_Resolve_Logic;
+            type unconstrained = null;
+        }
+        type SG = readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null];
+    }
+    type complexity = _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
+    namespace globals {
+    }
+    type globals = _T_Globals;
+    namespace imports {
+    }
+    type imports = _T_Imports;
+    namespace types {
+    }
+    type types = _T_Types;
+}
 export declare namespace _T_Schemas {
     namespace D {
         namespace SG {
             namespace schema {
-                namespace complexity {
-                    namespace SG {
-                        namespace constrained {
-                        }
-                        type constrained = _T_Resolve_Logic;
-                        type unconstrained = null;
-                    }
-                    type SG = readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null];
-                }
-                type complexity = _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-                namespace globals {
-                }
-                type globals = _T_Globals;
-                namespace imports {
-                }
-                type imports = _T_Imports;
-                namespace types {
-                }
-                type types = _T_Types;
             }
-            type schema = {
-                readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals;
-                readonly 'imports': _T_Imports;
-                readonly 'types': _T_Types;
-            };
+            type schema = _T_Schema;
             namespace _set {
             }
             type _set = _T_Schemas;
         }
-        type SG = readonly [
-            'schema',
-            {
-                readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals;
-                readonly 'imports': _T_Imports;
-                readonly 'types': _T_Types;
-            }
-        ] | readonly ['set', _T_Schemas];
+        type SG = readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas];
     }
-    type D = _i_core._T_State_Group<null, readonly [
-        'schema',
-        {
-            readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-            readonly 'globals': _T_Globals;
-            readonly 'imports': _T_Imports;
-            readonly 'types': _T_Types;
-        }
-    ] | readonly ['set', _T_Schemas]>;
+    type D = _i_core._T_State_Group<null, readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas]>;
 }
 export declare namespace _T_Signature {
     namespace parameters {
@@ -3330,59 +3310,40 @@ export declare namespace Resolvers {
         readonly 'type resolver': _T_Node_Resolver;
     };
 }
+export declare namespace Schema {
+    namespace complexity {
+        namespace SG {
+            namespace constrained {
+            }
+            type constrained = _T_Resolve_Logic;
+            type unconstrained = null;
+        }
+        type SG = readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null];
+    }
+    type complexity = _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
+    namespace globals {
+    }
+    type globals = _T_Globals;
+    namespace imports {
+    }
+    type imports = _T_Imports;
+    namespace types {
+    }
+    type types = _T_Types;
+}
 export declare namespace Schemas {
     namespace D {
         namespace SG {
             namespace schema {
-                namespace complexity {
-                    namespace SG {
-                        namespace constrained {
-                        }
-                        type constrained = _T_Resolve_Logic;
-                        type unconstrained = null;
-                    }
-                    type SG = readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null];
-                }
-                type complexity = _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-                namespace globals {
-                }
-                type globals = _T_Globals;
-                namespace imports {
-                }
-                type imports = _T_Imports;
-                namespace types {
-                }
-                type types = _T_Types;
             }
-            type schema = {
-                readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals;
-                readonly 'imports': _T_Imports;
-                readonly 'types': _T_Types;
-            };
+            type schema = _T_Schema;
             namespace _set {
             }
             type _set = _T_Schemas;
         }
-        type SG = readonly [
-            'schema',
-            {
-                readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals;
-                readonly 'imports': _T_Imports;
-                readonly 'types': _T_Types;
-            }
-        ] | readonly ['set', _T_Schemas];
+        type SG = readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas];
     }
-    type D = _i_core._T_State_Group<null, readonly [
-        'schema',
-        {
-            readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', _T_Resolve_Logic] | readonly ['unconstrained', null]>;
-            readonly 'globals': _T_Globals;
-            readonly 'imports': _T_Imports;
-            readonly 'types': _T_Types;
-        }
-    ] | readonly ['set', _T_Schemas]>;
+    type D = _i_core._T_State_Group<null, readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas]>;
 }
 export declare namespace Signature {
     namespace parameters {

package/dist/generated/interface/schemas/schema/unresolved.d.ts

@@ -230,15 +230,13 @@ export type _T_Resolvers<G_Source> = _i_core._T_Ordered_Dictionary<G_Source, {
     readonly 'signature': _i_core._T_Derived_Reference<G_Source, _T_Signatures.D<G_Source>>;
     readonly 'type resolver': _T_Node_Resolver<G_Source>;
 }>;
-export type _T_Schemas<G_Source> = _i_core._T_Ordered_Dictionary<G_Source, _i_core._T_State_Group<G_Source, readonly [
-    'schema',
-    {
-        readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-        readonly 'globals': _T_Globals<G_Source>;
-        readonly 'imports': _T_Imports<G_Source>;
-        readonly 'types': _T_Types<G_Source>;
-    }
-] | readonly ['set', _T_Schemas<G_Source>]>>;
+export type _T_Schema<G_Source> = {
+    readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
+    readonly 'globals': _T_Globals<G_Source>;
+    readonly 'imports': _T_Imports<G_Source>;
+    readonly 'types': _T_Types<G_Source>;
+};
+export type _T_Schemas<G_Source> = _i_core._T_Ordered_Dictionary<G_Source, _i_core._T_State_Group<G_Source, readonly ['schema', _T_Schema<G_Source>] | readonly ['set', _T_Schemas<G_Source>]>>;
 export type _T_Signature<G_Source> = {
     readonly 'parameters': _i_core._T_State_Group<G_Source, readonly ['local', _T_Signature_Parameters<G_Source>] | readonly ['same as', _i_core._T_Reference_To_Normal_Dictionary_Entry<G_Source, _T_Signatures.D<G_Source>>]>;
     readonly 'resolved parameters': _i_core._T_Derived_Reference<G_Source, _T_Signature_Parameters<G_Source>>;
@@ -336,6 +334,7 @@ export type Reference_To_Property_Constraint<G_Source> = _T_Reference_To_Propert
 export type Relative_Value_Selection<G_Source> = _T_Relative_Value_Selection<G_Source>;
 export type Resolve_Logic<G_Source> = _T_Resolve_Logic<G_Source>;
 export type Resolvers<G_Source> = _T_Resolvers<G_Source>;
+export type Schema<G_Source> = _T_Schema<G_Source>;
 export type Schemas<G_Source> = _T_Schemas<G_Source>;
 export type Signature<G_Source> = _T_Signature<G_Source>;
 export type Signature_Parameters<G_Source> = _T_Signature_Parameters<G_Source>;
@@ -1608,59 +1607,40 @@ export declare namespace _T_Resolvers {
         readonly 'type resolver': _T_Node_Resolver<G_Source>;
     };
 }
+export declare namespace _T_Schema {
+    namespace complexity {
+        namespace SG {
+            namespace constrained {
+            }
+            type constrained<G_Source> = _T_Resolve_Logic<G_Source>;
+            type unconstrained<G_Source> = null;
+        }
+        type SG<G_Source> = readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null];
+    }
+    type complexity<G_Source> = _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
+    namespace globals {
+    }
+    type globals<G_Source> = _T_Globals<G_Source>;
+    namespace imports {
+    }
+    type imports<G_Source> = _T_Imports<G_Source>;
+    namespace types {
+    }
+    type types<G_Source> = _T_Types<G_Source>;
+}
 export declare namespace _T_Schemas {
     namespace D {
         namespace SG {
             namespace schema {
-                namespace complexity {
-                    namespace SG {
-                        namespace constrained {
-                        }
-                        type constrained<G_Source> = _T_Resolve_Logic<G_Source>;
-                        type unconstrained<G_Source> = null;
-                    }
-                    type SG<G_Source> = readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null];
-                }
-                type complexity<G_Source> = _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-                namespace globals {
-                }
-                type globals<G_Source> = _T_Globals<G_Source>;
-                namespace imports {
-                }
-                type imports<G_Source> = _T_Imports<G_Source>;
-                namespace types {
-                }
-                type types<G_Source> = _T_Types<G_Source>;
             }
-            type schema<G_Source> = {
-                readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals<G_Source>;
-                readonly 'imports': _T_Imports<G_Source>;
-                readonly 'types': _T_Types<G_Source>;
-            };
+            type schema<G_Source> = _T_Schema<G_Source>;
             namespace _set {
             }
             type _set<G_Source> = _T_Schemas<G_Source>;
         }
-        type SG<G_Source> = readonly [
-            'schema',
-            {
-                readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals<G_Source>;
-                readonly 'imports': _T_Imports<G_Source>;
-                readonly 'types': _T_Types<G_Source>;
-            }
-        ] | readonly ['set', _T_Schemas<G_Source>];
+        type SG<G_Source> = readonly ['schema', _T_Schema<G_Source>] | readonly ['set', _T_Schemas<G_Source>];
     }
-    type D<G_Source> = _i_core._T_State_Group<G_Source, readonly [
-        'schema',
-        {
-            readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-            readonly 'globals': _T_Globals<G_Source>;
-            readonly 'imports': _T_Imports<G_Source>;
-            readonly 'types': _T_Types<G_Source>;
-        }
-    ] | readonly ['set', _T_Schemas<G_Source>]>;
+    type D<G_Source> = _i_core._T_State_Group<G_Source, readonly ['schema', _T_Schema<G_Source>] | readonly ['set', _T_Schemas<G_Source>]>;
 }
 export declare namespace _T_Signature {
     namespace parameters {
@@ -3330,59 +3310,40 @@ export declare namespace Resolvers {
         readonly 'type resolver': _T_Node_Resolver<G_Source>;
     };
 }
+export declare namespace Schema {
+    namespace complexity {
+        namespace SG {
+            namespace constrained {
+            }
+            type constrained<G_Source> = _T_Resolve_Logic<G_Source>;
+            type unconstrained<G_Source> = null;
+        }
+        type SG<G_Source> = readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null];
+    }
+    type complexity<G_Source> = _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
+    namespace globals {
+    }
+    type globals<G_Source> = _T_Globals<G_Source>;
+    namespace imports {
+    }
+    type imports<G_Source> = _T_Imports<G_Source>;
+    namespace types {
+    }
+    type types<G_Source> = _T_Types<G_Source>;
+}
 export declare namespace Schemas {
     namespace D {
         namespace SG {
             namespace schema {
-                namespace complexity {
-                    namespace SG {
-                        namespace constrained {
-                        }
-                        type constrained<G_Source> = _T_Resolve_Logic<G_Source>;
-                        type unconstrained<G_Source> = null;
-                    }
-                    type SG<G_Source> = readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null];
-                }
-                type complexity<G_Source> = _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-                namespace globals {
-                }
-                type globals<G_Source> = _T_Globals<G_Source>;
-                namespace imports {
-                }
-                type imports<G_Source> = _T_Imports<G_Source>;
-                namespace types {
-                }
-                type types<G_Source> = _T_Types<G_Source>;
             }
-            type schema<G_Source> = {
-                readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals<G_Source>;
-                readonly 'imports': _T_Imports<G_Source>;
-                readonly 'types': _T_Types<G_Source>;
-            };
+            type schema<G_Source> = _T_Schema<G_Source>;
             namespace _set {
             }
             type _set<G_Source> = _T_Schemas<G_Source>;
         }
-        type SG<G_Source> = readonly [
-            'schema',
-            {
-                readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-                readonly 'globals': _T_Globals<G_Source>;
-                readonly 'imports': _T_Imports<G_Source>;
-                readonly 'types': _T_Types<G_Source>;
-            }
-        ] | readonly ['set', _T_Schemas<G_Source>];
+        type SG<G_Source> = readonly ['schema', _T_Schema<G_Source>] | readonly ['set', _T_Schemas<G_Source>];
     }
-    type D<G_Source> = _i_core._T_State_Group<G_Source, readonly [
-        'schema',
-        {
-            readonly 'complexity': _i_core._T_State_Group<G_Source, readonly ['constrained', _T_Resolve_Logic<G_Source>] | readonly ['unconstrained', null]>;
-            readonly 'globals': _T_Globals<G_Source>;
-            readonly 'imports': _T_Imports<G_Source>;
-            readonly 'types': _T_Types<G_Source>;
-        }
-    ] | readonly ['set', _T_Schemas<G_Source>]>;
+    type D<G_Source> = _i_core._T_State_Group<G_Source, readonly ['schema', _T_Schema<G_Source>] | readonly ['set', _T_Schemas<G_Source>]>;
 }
 export declare namespace Signature {
     namespace parameters {