npm - pareto - Versions diffs - 0.76.43 → 0.76.44 - Mend

pareto 0.76.43 → 0.76.44

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (568) hide show

package/dist/generated/interface/schemas/schema/data_types/source.d.ts ADDED Viewed

@@ -0,0 +1,3786 @@
+import * as _pt from 'exupery-core-types';
+import * as _i_core from "../../../core/resolved";
+export type _T_Benchmark = {
+    readonly 'dense': boolean;
+    readonly 'resulting dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+    readonly 'selection': _T_Guaranteed_Value_Selection;
+};
+export type _T_Constraint = {
+    readonly 'selection': _T_Relative_Value_Selection;
+    readonly 'type': _i_core._T_State_Group<null, readonly [
+        'optional value',
+        {
+            readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+        }
+    ] | readonly [
+        'state',
+        {
+            readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+        }
+    ]>;
+};
+export type _T_Dictionary = {
+    readonly 'node': _T_Type_Node;
+    readonly 'ordered': boolean;
+};
+export type _T_Globals = {
+    readonly 'complexity': _i_core._T_State_Group<null, readonly ['constrained', null] | readonly ['unconstrained', null]>;
+    readonly 'number types': _i_core._T_Dictionary<null, _T_Number_Type>;
+    readonly 'text types': _i_core._T_Dictionary<null, _T_Text_Type>;
+};
+export type _T_Group = _i_core._T_Dictionary<null, _T_Type_Node>;
+export type _T_Guaranteed_Value_Selection = {
+    readonly 'resulting node': _i_core._T_Derived_Reference<null, _T_Type_Node>;
+    readonly 'start': _i_core._T_State_Group<null, readonly [
+        'constraint',
+        _i_core._T_State_Group<null, readonly [
+            'component',
+            {
+                readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ] | readonly [
+            'reference',
+            {
+                readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ]>
+    ] | readonly ['linked entry', null] | readonly ['list cursor', null] | readonly ['option constraint', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['parent sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>] | readonly [
+        'result',
+        _i_core._T_State_Group<null, readonly [
+            'list',
+            {
+                readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ] | readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>
+    ] | readonly ['sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>]>;
+    readonly 'tail': _T_Relative_Value_Selection;
+};
+export type _T_Imports = _i_core._T_Dictionary<null, {
+    readonly 'schema': _i_core._T_Derived_Reference<null, _T_Schema>;
+    readonly 'schema set child': _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
+}>;
+export type _T_Lookup_Selection = {
+    readonly 'resulting dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+    readonly 'type': _i_core._T_State_Group<null, readonly [
+        'dictionary',
+        {
+            readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'selection': _T_Guaranteed_Value_Selection;
+        }
+    ] | readonly ['not circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>] | readonly ['possibly circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>]>;
+};
+export type _T_Node_Resolver = _i_core._T_State_Group<null, readonly ['boolean', null] | readonly [
+    'component',
+    {
+        readonly 'arguments': _pt.Optional_Value<{
+            readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                'stack',
+                {
+                    readonly 'element': _T_Lookup_Selection;
+                    readonly 'stack': _T_Lookup_Selection;
+                }
+            ]>>>;
+            readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+        }>;
+        readonly 'constraints': _T_Property_Constraints;
+        readonly 'location': _i_core._T_State_Group<null, readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+        readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+    }
+] | readonly [
+    'dictionary',
+    {
+        readonly 'benchmark': _pt.Optional_Value<_T_Benchmark>;
+        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+        readonly 'resolver': _T_Node_Resolver;
+    }
+] | readonly ['group', _T_Node_Resolver_Group] | readonly ['identifier value pair', _T_Node_Resolver] | readonly [
+    'list',
+    {
+        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+        readonly 'resolver': _T_Node_Resolver;
+        readonly 'result': _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+    }
+] | readonly ['nothing', null] | readonly ['number', null] | readonly [
+    'optional',
+    {
+        readonly 'constraints': _T_Option_Constraints;
+        readonly 'resolver': _T_Node_Resolver;
+    }
+] | readonly [
+    'reference',
+    {
+        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+        readonly 'type': _i_core._T_State_Group<null, readonly [
+            'derived',
+            {
+                readonly 'value': _T_Guaranteed_Value_Selection;
+            }
+        ] | readonly [
+            'selected',
+            {
+                readonly 'constraints': _T_Property_Constraints;
+                readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                readonly 'lookup': _T_Lookup_Selection;
+            }
+        ]>;
+    }
+] | readonly [
+    'state group',
+    {
+        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+        readonly 'states': _i_core._T_Dictionary<null, {
+            readonly 'constraints': _T_Option_Constraints;
+            readonly 'resolver': _T_Node_Resolver;
+        }>;
+    }
+] | readonly ['text', null] | readonly ['type parameter', null]>;
+export type _T_Node_Resolver_Group = _i_core._T_Ordered_Dictionary<null, {
+    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Group.D>;
+    readonly 'resolver': _T_Node_Resolver;
+}>;
+export type _T_Node_Resolver_List_Result = _T_Type_Reference;
+export type _T_Number_Type = {
+    readonly 'precision': _i_core._T_State_Group<null, readonly [
+        'approximation',
+        {
+            readonly 'significant digits': number;
+        }
+    ] | readonly [
+        'exact',
+        {
+            readonly 'decimal separator offset': _pt.Optional_Value<number>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+        }
+    ]>;
+};
+export type _T_Option_Constraints = _i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['assert is set', _T_Possible_Value_Selection] | readonly [
+    'state',
+    {
+        readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+        readonly 'selection': _T_Guaranteed_Value_Selection;
+        readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+    }
+]>>;
+export type _T_Optional_Value_Initialization = _i_core._T_State_Group<null, readonly ['not set', null] | readonly ['selection', _T_Possible_Value_Selection] | readonly ['set', _T_Guaranteed_Value_Selection]>;
+export type _T_Possible_Value_Selection = _i_core._T_State_Group<null, readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly [
+    'result',
+    _i_core._T_State_Group<null, readonly [
+        'optional value',
+        {
+            readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+            readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            readonly 'result': _T_Type_Reference;
+        }
+    ] | readonly [
+        'state group',
+        {
+            readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            readonly 'result': _T_Type_Reference;
+            readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+        }
+    ]>
+]>;
+export type _T_Presence = _i_core._T_State_Group<null, readonly ['optional', null] | readonly ['required', null]>;
+export type _T_Property_Constraint = {
+    readonly 'constraint': _T_Constraint;
+    readonly 'start': _i_core._T_State_Group<null, readonly ['property', null] | readonly ['sibling', _T_Reference_To_Property_Constraint]>;
+};
+export type _T_Property_Constraints = _i_core._T_Ordered_Dictionary<null, _T_Property_Constraint>;
+export type _T_Reference_To_Property_Constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+export type _T_Relative_Value_Selection = {
+    readonly 'path': _i_core._T_List<null, _i_core._T_State_Group<null, readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+        'reference',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+        }
+    ]>>;
+    readonly 'resulting node': _i_core._T_Derived_Reference<null, _T_Type_Node>;
+};
+export type _T_Resolve_Logic = {
+    readonly 'resolvers': _T_Resolvers;
+    readonly 'signatures': {
+        readonly 'types': _T_Signatures;
+    };
+};
+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_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_Schema_Tree = _i_core._T_State_Group<null, readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas]>;
+export type _T_Schemas = _i_core._T_Ordered_Dictionary<null, _T_Schema_Tree>;
+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>;
+    readonly 'type': _i_core._T_Derived_Reference<null, _T_Type>;
+};
+export type _T_Signature_Parameters = {
+    readonly 'lookups': _i_core._T_Dictionary<null, {
+        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+        readonly 'presence': _T_Presence;
+        readonly 'referent': _T_Type_Reference;
+        readonly 'type': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+    }>;
+    readonly 'values': _i_core._T_Dictionary<null, {
+        readonly 'data type': _T_Type_Reference;
+        readonly 'presence': _T_Presence;
+    }>;
+};
+export type _T_Signatures = _i_core._T_Ordered_Dictionary<null, _T_Signature>;
+export type _T_Text_Type = {
+    readonly 'type': _i_core._T_State_Group<null, readonly ['multi line', null] | readonly ['single line', null]>;
+};
+export type _T_Type = {
+    readonly 'node': _T_Type_Node;
+    readonly 'type parameters': _T_Type_Parameters;
+};
+export type _T_Type_Node = _i_core._T_State_Group<null, readonly ['boolean', null] | readonly [
+    'component',
+    _i_core._T_State_Group<null, readonly [
+        'external',
+        {
+            readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+            readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+        }
+    ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>
+] | readonly ['dictionary', _T_Dictionary] | readonly ['group', _T_Group] | readonly ['identifier value pair', _T_Type_Node] | readonly [
+    'list',
+    {
+        readonly 'node': _T_Type_Node;
+    }
+] | readonly ['nothing', null] | readonly [
+    'number',
+    _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type]>
+] | readonly ['optional', _T_Type_Node] | readonly [
+    'reference',
+    {
+        readonly 'referent': _T_Type_Node_Reference;
+        readonly 'type': _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+            'selected',
+            {
+                readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            }
+        ]>;
+    }
+] | readonly ['state group', _i_core._T_Dictionary<null, _T_Type_Node>] | readonly [
+    'text',
+    _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>
+] | readonly ['type parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Parameters.D>]>;
+export type _T_Type_Node_Reference = {
+    readonly 'resulting node': _i_core._T_Derived_Reference<null, _T_Type_Node>;
+    readonly 'tail': _i_core._T_List<null, _i_core._T_State_Group<null, readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>]>>;
+    readonly 'type location': _T_Type_Reference;
+};
+export type _T_Type_Parameters = _i_core._T_Dictionary<null, null>;
+export type _T_Type_Reference = {
+    readonly 'location': _i_core._T_State_Group<null, readonly [
+        'external',
+        {
+            readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+            readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+        }
+    ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>]>;
+    readonly 'resulting node': _i_core._T_Derived_Reference<null, _T_Type_Node>;
+};
+export type _T_Type_Specification = {
+    readonly 'schema': _T_Schema_Tree;
+    readonly 'schema path': _i_core._T_List<null, string>;
+    readonly 'type': string;
+};
+export type _T_Types = _i_core._T_Ordered_Dictionary<null, _T_Type>;
+export type Benchmark = _T_Benchmark;
+export type Constraint = _T_Constraint;
+export type Dictionary = _T_Dictionary;
+export type Globals = _T_Globals;
+export type Group = _T_Group;
+export type Guaranteed_Value_Selection = _T_Guaranteed_Value_Selection;
+export type Imports = _T_Imports;
+export type Lookup_Selection = _T_Lookup_Selection;
+export type Node_Resolver = _T_Node_Resolver;
+export type Node_Resolver_Group = _T_Node_Resolver_Group;
+export type Node_Resolver_List_Result = _T_Node_Resolver_List_Result;
+export type Number_Type = _T_Number_Type;
+export type Option_Constraints = _T_Option_Constraints;
+export type Optional_Value_Initialization = _T_Optional_Value_Initialization;
+export type Possible_Value_Selection = _T_Possible_Value_Selection;
+export type Presence = _T_Presence;
+export type Property_Constraint = _T_Property_Constraint;
+export type Property_Constraints = _T_Property_Constraints;
+export type Reference_To_Property_Constraint = _T_Reference_To_Property_Constraint;
+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 Schema_Tree = _T_Schema_Tree;
+export type Schemas = _T_Schemas;
+export type Signature = _T_Signature;
+export type Signature_Parameters = _T_Signature_Parameters;
+export type Signatures = _T_Signatures;
+export type Text_Type = _T_Text_Type;
+export type Type = _T_Type;
+export type Type_Node = _T_Type_Node;
+export type Type_Node_Reference = _T_Type_Node_Reference;
+export type Type_Parameters = _T_Type_Parameters;
+export type Type_Reference = _T_Type_Reference;
+export type Type_Specification = _T_Type_Specification;
+export type Types = _T_Types;
+export declare namespace _T_Benchmark {
+    type dense = boolean;
+    namespace resulting_dictionary {
+        namespace Type {
+        }
+        type Type = _T_Dictionary;
+    }
+    type resulting_dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+    namespace selection {
+    }
+    type selection = _T_Guaranteed_Value_Selection;
+}
+export declare namespace _T_Constraint {
+    namespace selection {
+    }
+    type selection = _T_Relative_Value_Selection;
+    namespace _type {
+        namespace SG {
+            namespace optional_value {
+                namespace selected_optional_value {
+                    namespace Type {
+                    }
+                    type Type = _T_Type_Node.SG.optional;
+                }
+                type selected_optional_value = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+            }
+            type optional_value = {
+                readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+            };
+            namespace state {
+                namespace selected_state_group {
+                    namespace Type {
+                    }
+                    type Type = _T_Type_Node.SG.state_group;
+                }
+                type selected_state_group = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                namespace state {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Type_Node.SG.state_group.D;
+                }
+                type state = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+            type state = {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            };
+        }
+        type SG = readonly [
+            'optional value',
+            {
+                readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+            }
+        ] | readonly [
+            'state',
+            {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+        ];
+    }
+    type _type = _i_core._T_State_Group<null, readonly [
+        'optional value',
+        {
+            readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+        }
+    ] | readonly [
+        'state',
+        {
+            readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+        }
+    ]>;
+}
+export declare namespace _T_Dictionary {
+    namespace node {
+    }
+    type node = _T_Type_Node;
+    type ordered = boolean;
+}
+export declare namespace _T_Globals {
+    namespace complexity {
+        namespace SG {
+            type constrained = null;
+            type unconstrained = null;
+        }
+        type SG = readonly ['constrained', null] | readonly ['unconstrained', null];
+    }
+    type complexity = _i_core._T_State_Group<null, readonly ['constrained', null] | readonly ['unconstrained', null]>;
+    namespace number_types {
+        namespace D {
+        }
+        type D = _T_Number_Type;
+    }
+    type number_types = _i_core._T_Dictionary<null, _T_Number_Type>;
+    namespace text_types {
+        namespace D {
+        }
+        type D = _T_Text_Type;
+    }
+    type text_types = _i_core._T_Dictionary<null, _T_Text_Type>;
+}
+export declare namespace _T_Group {
+    namespace D {
+    }
+    type D = _T_Type_Node;
+}
+export declare namespace _T_Guaranteed_Value_Selection {
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+    namespace start {
+        namespace SG {
+            namespace constraint {
+                namespace SG {
+                    namespace component {
+                        namespace constraint {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Property_Constraints.D;
+                        }
+                        type constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                    type component = {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    };
+                    namespace reference {
+                        namespace constraint {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Property_Constraints.D;
+                        }
+                        type constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                    type reference = {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    };
+                }
+                type SG = readonly [
+                    'component',
+                    {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                ] | readonly [
+                    'reference',
+                    {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                ];
+            }
+            type constraint = _i_core._T_State_Group<null, readonly [
+                'component',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'reference',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ]>;
+            type linked_entry = null;
+            type list_cursor = null;
+            namespace option_constraint {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Option_Constraints.D;
+            }
+            type option_constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>;
+            namespace parameter {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Signature_Parameters.values.D;
+            }
+            type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>;
+            namespace parent_sibling {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Node_Resolver_Group.D;
+            }
+            type parent_sibling = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            namespace result {
+                namespace SG {
+                    namespace list {
+                        namespace list_result {
+                            namespace Type {
+                            }
+                            type Type = _T_Node_Resolver.SG.list.result.O;
+                        }
+                        type list_result = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                    type list = {
+                        readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    };
+                    namespace optional_value {
+                        namespace optional_value {
+                            namespace Type {
+                            }
+                            type Type = _T_Node_Resolver.SG.optional;
+                        }
+                        type optional_value = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        namespace result {
+                        }
+                        type result = _T_Type_Reference;
+                    }
+                    type optional_value = {
+                        readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                    };
+                    namespace state_group {
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        namespace result {
+                        }
+                        type result = _T_Type_Reference;
+                        namespace state_group {
+                            namespace Type {
+                            }
+                            type Type = _T_Node_Resolver.SG.state_group;
+                        }
+                        type state_group = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                    }
+                    type state_group = {
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                        readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                    };
+                }
+                type SG = readonly [
+                    'list',
+                    {
+                        readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                ] | readonly [
+                    'optional value',
+                    {
+                        readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                    }
+                ] | readonly [
+                    'state group',
+                    {
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                        readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                    }
+                ];
+            }
+            type result = _i_core._T_State_Group<null, readonly [
+                'list',
+                {
+                    readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'optional value',
+                {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                }
+            ] | readonly [
+                'state group',
+                {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+            ]>;
+            namespace sibling {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Node_Resolver_Group.D;
+            }
+            type sibling = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+        }
+        type SG = readonly [
+            'constraint',
+            _i_core._T_State_Group<null, readonly [
+                'component',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'reference',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ]>
+        ] | readonly ['linked entry', null] | readonly ['list cursor', null] | readonly ['option constraint', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['parent sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>] | readonly [
+            'result',
+            _i_core._T_State_Group<null, readonly [
+                'list',
+                {
+                    readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'optional value',
+                {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                }
+            ] | readonly [
+                'state group',
+                {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+            ]>
+        ] | readonly ['sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>];
+    }
+    type start = _i_core._T_State_Group<null, readonly [
+        'constraint',
+        _i_core._T_State_Group<null, readonly [
+            'component',
+            {
+                readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ] | readonly [
+            'reference',
+            {
+                readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ]>
+    ] | readonly ['linked entry', null] | readonly ['list cursor', null] | readonly ['option constraint', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['parent sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>] | readonly [
+        'result',
+        _i_core._T_State_Group<null, readonly [
+            'list',
+            {
+                readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ] | readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>
+    ] | readonly ['sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>]>;
+    namespace tail {
+    }
+    type tail = _T_Relative_Value_Selection;
+}
+export declare namespace _T_Imports {
+    namespace D {
+        namespace schema {
+            namespace Type {
+            }
+            type Type = _T_Schema;
+        }
+        type schema = _i_core._T_Derived_Reference<null, _T_Schema>;
+        namespace schema_set_child {
+            namespace Dictionary_Entry {
+            }
+            type Dictionary_Entry = _T_Schemas.D;
+        }
+        type schema_set_child = _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
+    }
+    type D = {
+        readonly 'schema': _i_core._T_Derived_Reference<null, _T_Schema>;
+        readonly 'schema set child': _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
+    };
+}
+export declare namespace _T_Lookup_Selection {
+    namespace resulting_dictionary {
+        namespace Type {
+        }
+        type Type = _T_Dictionary;
+    }
+    type resulting_dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+    namespace _type {
+        namespace SG {
+            namespace dictionary {
+                namespace selected_dictionary {
+                    namespace Type {
+                    }
+                    type Type = _T_Dictionary;
+                }
+                type selected_dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                namespace selection {
+                }
+                type selection = _T_Guaranteed_Value_Selection;
+            }
+            type dictionary = {
+                readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+            };
+            namespace not_circular_dependent_siblings {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type not_circular_dependent_siblings = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            namespace parameter {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Signature_Parameters.lookups.D;
+            }
+            type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>;
+            namespace possibly_circular_dependent_siblings {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type possibly_circular_dependent_siblings = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+        }
+        type SG = readonly [
+            'dictionary',
+            {
+                readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+            }
+        ] | readonly ['not circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>] | readonly ['possibly circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>];
+    }
+    type _type = _i_core._T_State_Group<null, readonly [
+        'dictionary',
+        {
+            readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'selection': _T_Guaranteed_Value_Selection;
+        }
+    ] | readonly ['not circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>] | readonly ['possibly circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>]>;
+}
+export declare namespace _T_Node_Resolver {
+    namespace SG {
+        type _boolean = null;
+        namespace component {
+            namespace _arguments {
+                namespace O {
+                    namespace lookups {
+                        namespace O {
+                            namespace D {
+                                namespace SG {
+                                    type empty_stack = null;
+                                    type not_set = null;
+                                    namespace selection {
+                                    }
+                                    type selection = _T_Lookup_Selection;
+                                    namespace stack {
+                                        namespace element {
+                                        }
+                                        type element = _T_Lookup_Selection;
+                                        namespace stack {
+                                        }
+                                        type stack = _T_Lookup_Selection;
+                                    }
+                                    type stack = {
+                                        readonly 'element': _T_Lookup_Selection;
+                                        readonly 'stack': _T_Lookup_Selection;
+                                    };
+                                }
+                                type SG = readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                                    'stack',
+                                    {
+                                        readonly 'element': _T_Lookup_Selection;
+                                        readonly 'stack': _T_Lookup_Selection;
+                                    }
+                                ];
+                            }
+                            type D = _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                                'stack',
+                                {
+                                    readonly 'element': _T_Lookup_Selection;
+                                    readonly 'stack': _T_Lookup_Selection;
+                                }
+                            ]>;
+                        }
+                        type O = _i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                            'stack',
+                            {
+                                readonly 'element': _T_Lookup_Selection;
+                                readonly 'stack': _T_Lookup_Selection;
+                            }
+                        ]>>;
+                    }
+                    type lookups = _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                        'stack',
+                        {
+                            readonly 'element': _T_Lookup_Selection;
+                            readonly 'stack': _T_Lookup_Selection;
+                        }
+                    ]>>>;
+                    namespace values {
+                        namespace O {
+                            namespace D {
+                                namespace SG {
+                                    namespace optional {
+                                    }
+                                    type optional = _T_Optional_Value_Initialization;
+                                    namespace parameter {
+                                        namespace Dictionary_Entry {
+                                        }
+                                        type Dictionary_Entry = _T_Signature_Parameters.values.D;
+                                    }
+                                    type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>;
+                                    namespace required {
+                                    }
+                                    type required = _T_Guaranteed_Value_Selection;
+                                }
+                                type SG = readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection];
+                            }
+                            type D = _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>;
+                        }
+                        type O = _i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>;
+                    }
+                    type values = _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+                }
+                type O = {
+                    readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                        'stack',
+                        {
+                            readonly 'element': _T_Lookup_Selection;
+                            readonly 'stack': _T_Lookup_Selection;
+                        }
+                    ]>>>;
+                    readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+                };
+            }
+            type _arguments = _pt.Optional_Value<{
+                readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                    'stack',
+                    {
+                        readonly 'element': _T_Lookup_Selection;
+                        readonly 'stack': _T_Lookup_Selection;
+                    }
+                ]>>>;
+                readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+            }>;
+            namespace constraints {
+            }
+            type constraints = _T_Property_Constraints;
+            namespace location {
+                namespace SG {
+                    namespace external {
+                        namespace _import {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Imports.D;
+                        }
+                        type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                        namespace _type {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Signatures.D;
+                        }
+                        type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                    }
+                    type external = {
+                        readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                        readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                    };
+                    namespace internal {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Signatures.D;
+                    }
+                    type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+                type SG = readonly [
+                    'external',
+                    {
+                        readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                        readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                    }
+                ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>];
+            }
+            type location = _i_core._T_State_Group<null, readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+            namespace signature {
+                namespace Type {
+                }
+                type Type = _T_Signatures.D;
+            }
+            type signature = _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        }
+        type component = {
+            readonly 'arguments': _pt.Optional_Value<{
+                readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                    'stack',
+                    {
+                        readonly 'element': _T_Lookup_Selection;
+                        readonly 'stack': _T_Lookup_Selection;
+                    }
+                ]>>>;
+                readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+            }>;
+            readonly 'constraints': _T_Property_Constraints;
+            readonly 'location': _i_core._T_State_Group<null, readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+            readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        };
+        namespace dictionary {
+            namespace benchmark {
+                namespace O {
+                }
+                type O = _T_Benchmark;
+            }
+            type benchmark = _pt.Optional_Value<_T_Benchmark>;
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            namespace resolver {
+            }
+            type resolver = _T_Node_Resolver;
+        }
+        type dictionary = {
+            readonly 'benchmark': _pt.Optional_Value<_T_Benchmark>;
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'resolver': _T_Node_Resolver;
+        };
+        namespace group {
+        }
+        type group = _T_Node_Resolver_Group;
+        namespace identifier_value_pair {
+        }
+        type identifier_value_pair = _T_Node_Resolver;
+        namespace list {
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Type_Node.SG.list;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+            namespace resolver {
+            }
+            type resolver = _T_Node_Resolver;
+            namespace result {
+                namespace O {
+                }
+                type O = _T_Node_Resolver_List_Result;
+            }
+            type result = _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+        }
+        type list = {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+            readonly 'resolver': _T_Node_Resolver;
+            readonly 'result': _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+        };
+        type nothing = null;
+        type _number = null;
+        namespace optional {
+            namespace constraints {
+            }
+            type constraints = _T_Option_Constraints;
+            namespace resolver {
+            }
+            type resolver = _T_Node_Resolver;
+        }
+        type optional = {
+            readonly 'constraints': _T_Option_Constraints;
+            readonly 'resolver': _T_Node_Resolver;
+        };
+        namespace reference {
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Type_Node.SG.reference;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            namespace _type {
+                namespace SG {
+                    namespace derived {
+                        namespace value {
+                        }
+                        type value = _T_Guaranteed_Value_Selection;
+                    }
+                    type derived = {
+                        readonly 'value': _T_Guaranteed_Value_Selection;
+                    };
+                    namespace selected {
+                        namespace constraints {
+                        }
+                        type constraints = _T_Property_Constraints;
+                        namespace definition {
+                            namespace Type {
+                            }
+                            type Type = _T_Type_Node.SG.reference._type.SG.selected;
+                        }
+                        type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                        namespace lookup {
+                        }
+                        type lookup = _T_Lookup_Selection;
+                    }
+                    type selected = {
+                        readonly 'constraints': _T_Property_Constraints;
+                        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                        readonly 'lookup': _T_Lookup_Selection;
+                    };
+                }
+                type SG = readonly [
+                    'derived',
+                    {
+                        readonly 'value': _T_Guaranteed_Value_Selection;
+                    }
+                ] | readonly [
+                    'selected',
+                    {
+                        readonly 'constraints': _T_Property_Constraints;
+                        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                        readonly 'lookup': _T_Lookup_Selection;
+                    }
+                ];
+            }
+            type _type = _i_core._T_State_Group<null, readonly [
+                'derived',
+                {
+                    readonly 'value': _T_Guaranteed_Value_Selection;
+                }
+            ] | readonly [
+                'selected',
+                {
+                    readonly 'constraints': _T_Property_Constraints;
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                    readonly 'lookup': _T_Lookup_Selection;
+                }
+            ]>;
+        }
+        type reference = {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            readonly 'type': _i_core._T_State_Group<null, readonly [
+                'derived',
+                {
+                    readonly 'value': _T_Guaranteed_Value_Selection;
+                }
+            ] | readonly [
+                'selected',
+                {
+                    readonly 'constraints': _T_Property_Constraints;
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                    readonly 'lookup': _T_Lookup_Selection;
+                }
+            ]>;
+        };
+        namespace state_group {
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Type_Node.SG.state_group;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            namespace states {
+                namespace D {
+                    namespace constraints {
+                    }
+                    type constraints = _T_Option_Constraints;
+                    namespace resolver {
+                    }
+                    type resolver = _T_Node_Resolver;
+                }
+                type D = {
+                    readonly 'constraints': _T_Option_Constraints;
+                    readonly 'resolver': _T_Node_Resolver;
+                };
+            }
+            type states = _i_core._T_Dictionary<null, {
+                readonly 'constraints': _T_Option_Constraints;
+                readonly 'resolver': _T_Node_Resolver;
+            }>;
+        }
+        type state_group = {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'states': _i_core._T_Dictionary<null, {
+                readonly 'constraints': _T_Option_Constraints;
+                readonly 'resolver': _T_Node_Resolver;
+            }>;
+        };
+        type text = null;
+        type type_parameter = null;
+    }
+    type SG = readonly ['boolean', null] | readonly [
+        'component',
+        {
+            readonly 'arguments': _pt.Optional_Value<{
+                readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                    'stack',
+                    {
+                        readonly 'element': _T_Lookup_Selection;
+                        readonly 'stack': _T_Lookup_Selection;
+                    }
+                ]>>>;
+                readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+            }>;
+            readonly 'constraints': _T_Property_Constraints;
+            readonly 'location': _i_core._T_State_Group<null, readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+            readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        }
+    ] | readonly [
+        'dictionary',
+        {
+            readonly 'benchmark': _pt.Optional_Value<_T_Benchmark>;
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'resolver': _T_Node_Resolver;
+        }
+    ] | readonly ['group', _T_Node_Resolver_Group] | readonly ['identifier value pair', _T_Node_Resolver] | readonly [
+        'list',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+            readonly 'resolver': _T_Node_Resolver;
+            readonly 'result': _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+        }
+    ] | readonly ['nothing', null] | readonly ['number', null] | readonly [
+        'optional',
+        {
+            readonly 'constraints': _T_Option_Constraints;
+            readonly 'resolver': _T_Node_Resolver;
+        }
+    ] | readonly [
+        'reference',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            readonly 'type': _i_core._T_State_Group<null, readonly [
+                'derived',
+                {
+                    readonly 'value': _T_Guaranteed_Value_Selection;
+                }
+            ] | readonly [
+                'selected',
+                {
+                    readonly 'constraints': _T_Property_Constraints;
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                    readonly 'lookup': _T_Lookup_Selection;
+                }
+            ]>;
+        }
+    ] | readonly [
+        'state group',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'states': _i_core._T_Dictionary<null, {
+                readonly 'constraints': _T_Option_Constraints;
+                readonly 'resolver': _T_Node_Resolver;
+            }>;
+        }
+    ] | readonly ['text', null] | readonly ['type parameter', null];
+}
+export declare namespace _T_Node_Resolver_Group {
+    namespace D {
+        namespace definition {
+            namespace Type {
+            }
+            type Type = _T_Group.D;
+        }
+        type definition = _i_core._T_Derived_Reference<null, _T_Group.D>;
+        namespace resolver {
+        }
+        type resolver = _T_Node_Resolver;
+    }
+    type D = {
+        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Group.D>;
+        readonly 'resolver': _T_Node_Resolver;
+    };
+}
+export declare namespace _T_Node_Resolver_List_Result {
+}
+export declare namespace _T_Number_Type {
+    namespace precision {
+        namespace SG {
+            namespace approximation {
+                type significant_digits = number;
+            }
+            type approximation = {
+                readonly 'significant digits': number;
+            };
+            namespace exact {
+                namespace decimal_separator_offset {
+                    type O = number;
+                }
+                type decimal_separator_offset = _pt.Optional_Value<number>;
+                namespace _type {
+                    namespace SG {
+                        type integer = null;
+                        type natural = null;
+                        type positive_natural = null;
+                    }
+                    type SG = readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null];
+                }
+                type _type = _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+            }
+            type exact = {
+                readonly 'decimal separator offset': _pt.Optional_Value<number>;
+                readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+            };
+        }
+        type SG = readonly [
+            'approximation',
+            {
+                readonly 'significant digits': number;
+            }
+        ] | readonly [
+            'exact',
+            {
+                readonly 'decimal separator offset': _pt.Optional_Value<number>;
+                readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+            }
+        ];
+    }
+    type precision = _i_core._T_State_Group<null, readonly [
+        'approximation',
+        {
+            readonly 'significant digits': number;
+        }
+    ] | readonly [
+        'exact',
+        {
+            readonly 'decimal separator offset': _pt.Optional_Value<number>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+        }
+    ]>;
+}
+export declare namespace _T_Option_Constraints {
+    namespace D {
+        namespace SG {
+            namespace assert_is_set {
+            }
+            type assert_is_set = _T_Possible_Value_Selection;
+            namespace state {
+                namespace selected_state_group {
+                    namespace Type {
+                    }
+                    type Type = _T_Type_Node.SG.state_group;
+                }
+                type selected_state_group = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                namespace selection {
+                }
+                type selection = _T_Guaranteed_Value_Selection;
+                namespace state {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Type_Node.SG.state_group.D;
+                }
+                type state = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+            type state = {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            };
+        }
+        type SG = readonly ['assert is set', _T_Possible_Value_Selection] | readonly [
+            'state',
+            {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+        ];
+    }
+    type D = _i_core._T_State_Group<null, readonly ['assert is set', _T_Possible_Value_Selection] | readonly [
+        'state',
+        {
+            readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'selection': _T_Guaranteed_Value_Selection;
+            readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+        }
+    ]>;
+}
+export declare namespace _T_Optional_Value_Initialization {
+    namespace SG {
+        type not_set = null;
+        namespace selection {
+        }
+        type selection = _T_Possible_Value_Selection;
+        namespace _set {
+        }
+        type _set = _T_Guaranteed_Value_Selection;
+    }
+    type SG = readonly ['not set', null] | readonly ['selection', _T_Possible_Value_Selection] | readonly ['set', _T_Guaranteed_Value_Selection];
+}
+export declare namespace _T_Possible_Value_Selection {
+    namespace SG {
+        namespace parameter {
+            namespace Dictionary_Entry {
+            }
+            type Dictionary_Entry = _T_Signature_Parameters.values.D;
+        }
+        type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>;
+        namespace result {
+            namespace SG {
+                namespace optional_value {
+                    namespace optional_value {
+                        namespace Type {
+                        }
+                        type Type = _T_Node_Resolver.SG.optional;
+                    }
+                    type optional_value = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    namespace property {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                    }
+                    type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    namespace result {
+                    }
+                    type result = _T_Type_Reference;
+                }
+                type optional_value = {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                };
+                namespace state_group {
+                    namespace property {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                    }
+                    type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    namespace result {
+                    }
+                    type result = _T_Type_Reference;
+                    namespace state_group {
+                        namespace Type {
+                        }
+                        type Type = _T_Node_Resolver.SG.state_group;
+                    }
+                    type state_group = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+                type state_group = {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                };
+            }
+            type SG = readonly [
+                'optional value',
+                {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                }
+            ] | readonly [
+                'state group',
+                {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+            ];
+        }
+        type result = _i_core._T_State_Group<null, readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>;
+    }
+    type SG = readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly [
+        'result',
+        _i_core._T_State_Group<null, readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>
+    ];
+}
+export declare namespace _T_Presence {
+    namespace SG {
+        type optional = null;
+        type required = null;
+    }
+    type SG = readonly ['optional', null] | readonly ['required', null];
+}
+export declare namespace _T_Property_Constraint {
+    namespace constraint {
+    }
+    type constraint = _T_Constraint;
+    namespace start {
+        namespace SG {
+            type property = null;
+            namespace sibling {
+            }
+            type sibling = _T_Reference_To_Property_Constraint;
+        }
+        type SG = readonly ['property', null] | readonly ['sibling', _T_Reference_To_Property_Constraint];
+    }
+    type start = _i_core._T_State_Group<null, readonly ['property', null] | readonly ['sibling', _T_Reference_To_Property_Constraint]>;
+}
+export declare namespace _T_Property_Constraints {
+    namespace D {
+    }
+    type D = _T_Property_Constraint;
+}
+export declare namespace _T_Reference_To_Property_Constraint {
+    namespace Dictionary_Entry {
+    }
+    type Dictionary_Entry = _T_Property_Constraints.D;
+}
+export declare namespace _T_Relative_Value_Selection {
+    namespace path {
+        namespace L {
+            namespace SG {
+                type component = null;
+                namespace group {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Group.D;
+                }
+                type group = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>;
+                namespace reference {
+                    namespace definition {
+                        namespace Type {
+                        }
+                        type Type = _T_Type_Node.SG.reference;
+                    }
+                    type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+                }
+                type reference = {
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+                };
+            }
+            type SG = readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+                'reference',
+                {
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+                }
+            ];
+        }
+        type L = _i_core._T_State_Group<null, readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+            'reference',
+            {
+                readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            }
+        ]>;
+    }
+    type path = _i_core._T_List<null, _i_core._T_State_Group<null, readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+        'reference',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+        }
+    ]>>;
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+}
+export declare namespace _T_Resolve_Logic {
+    namespace resolvers {
+    }
+    type resolvers = _T_Resolvers;
+    namespace signatures {
+        namespace types {
+        }
+        type types = _T_Signatures;
+    }
+    type signatures = {
+        readonly 'types': _T_Signatures;
+    };
+}
+export declare namespace _T_Resolvers {
+    namespace D {
+        namespace signature {
+            namespace Type {
+            }
+            type Type = _T_Signatures.D;
+        }
+        type signature = _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        namespace type_resolver {
+        }
+        type type_resolver = _T_Node_Resolver;
+    }
+    type D = {
+        readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        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_Schema_Tree {
+    namespace SG {
+        namespace schema {
+        }
+        type schema = _T_Schema;
+        namespace _set {
+        }
+        type _set = _T_Schemas;
+    }
+    type SG = readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas];
+}
+export declare namespace _T_Schemas {
+    namespace D {
+    }
+    type D = _T_Schema_Tree;
+}
+export declare namespace _T_Signature {
+    namespace parameters {
+        namespace SG {
+            namespace local {
+            }
+            type local = _T_Signature_Parameters;
+            namespace same_as {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Signatures.D;
+            }
+            type same_as = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+        }
+        type SG = readonly ['local', _T_Signature_Parameters] | readonly ['same as', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>];
+    }
+    type 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>]>;
+    namespace resolved_parameters {
+        namespace Type {
+        }
+        type Type = _T_Signature_Parameters;
+    }
+    type resolved_parameters = _i_core._T_Derived_Reference<null, _T_Signature_Parameters>;
+    namespace _type {
+        namespace Type {
+        }
+        type Type = _T_Type;
+    }
+    type _type = _i_core._T_Derived_Reference<null, _T_Type>;
+}
+export declare namespace _T_Signature_Parameters {
+    namespace lookups {
+        namespace D {
+            namespace dictionary {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            namespace presence {
+            }
+            type presence = _T_Presence;
+            namespace referent {
+            }
+            type referent = _T_Type_Reference;
+            namespace _type {
+                namespace SG {
+                    type acyclic = null;
+                    type cyclic = null;
+                    type stack = null;
+                }
+                type SG = readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null];
+            }
+            type _type = _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+        }
+        type D = {
+            readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'presence': _T_Presence;
+            readonly 'referent': _T_Type_Reference;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+        };
+    }
+    type lookups = _i_core._T_Dictionary<null, {
+        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+        readonly 'presence': _T_Presence;
+        readonly 'referent': _T_Type_Reference;
+        readonly 'type': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+    }>;
+    namespace values {
+        namespace D {
+            namespace data_type {
+            }
+            type data_type = _T_Type_Reference;
+            namespace presence {
+            }
+            type presence = _T_Presence;
+        }
+        type D = {
+            readonly 'data type': _T_Type_Reference;
+            readonly 'presence': _T_Presence;
+        };
+    }
+    type values = _i_core._T_Dictionary<null, {
+        readonly 'data type': _T_Type_Reference;
+        readonly 'presence': _T_Presence;
+    }>;
+}
+export declare namespace _T_Signatures {
+    namespace D {
+    }
+    type D = _T_Signature;
+}
+export declare namespace _T_Text_Type {
+    namespace _type {
+        namespace SG {
+            type multi_line = null;
+            type single_line = null;
+        }
+        type SG = readonly ['multi line', null] | readonly ['single line', null];
+    }
+    type _type = _i_core._T_State_Group<null, readonly ['multi line', null] | readonly ['single line', null]>;
+}
+export declare namespace _T_Type {
+    namespace node {
+    }
+    type node = _T_Type_Node;
+    namespace type_parameters {
+    }
+    type type_parameters = _T_Type_Parameters;
+}
+export declare namespace _T_Type_Node {
+    namespace SG {
+        type _boolean = null;
+        namespace component {
+            namespace SG {
+                namespace external {
+                    namespace _import {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Imports.D;
+                    }
+                    type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    namespace _type {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Types.D;
+                    }
+                    type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                }
+                type external = {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                };
+                namespace internal {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Types.D;
+                }
+                type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                namespace internal_cyclic {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Types.D;
+                }
+                type internal_cyclic = _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>;
+            }
+            type SG = readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>];
+        }
+        type component = _i_core._T_State_Group<null, readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>;
+        namespace dictionary {
+        }
+        type dictionary = _T_Dictionary;
+        namespace group {
+        }
+        type group = _T_Group;
+        namespace identifier_value_pair {
+        }
+        type identifier_value_pair = _T_Type_Node;
+        namespace list {
+            namespace node {
+            }
+            type node = _T_Type_Node;
+        }
+        type list = {
+            readonly 'node': _T_Type_Node;
+        };
+        type nothing = null;
+        namespace _number {
+            namespace SG {
+                namespace global {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Globals.number_types.D;
+                }
+                type global = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>;
+                namespace local {
+                }
+                type local = _T_Number_Type;
+            }
+            type SG = readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type];
+        }
+        type _number = _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type]>;
+        namespace optional {
+        }
+        type optional = _T_Type_Node;
+        namespace reference {
+            namespace referent {
+            }
+            type referent = _T_Type_Node_Reference;
+            namespace _type {
+                namespace SG {
+                    type derived = null;
+                    namespace selected {
+                        namespace dependency {
+                            namespace SG {
+                                type acyclic = null;
+                                type cyclic = null;
+                                type stack = null;
+                            }
+                            type SG = readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null];
+                        }
+                        type dependency = _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                        namespace dictionary {
+                            namespace Type {
+                            }
+                            type Type = _T_Dictionary;
+                        }
+                        type dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                    }
+                    type selected = {
+                        readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                    };
+                }
+                type SG = readonly ['derived', null] | readonly [
+                    'selected',
+                    {
+                        readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                    }
+                ];
+            }
+            type _type = _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+                'selected',
+                {
+                    readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                    readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                }
+            ]>;
+        }
+        type reference = {
+            readonly 'referent': _T_Type_Node_Reference;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+                'selected',
+                {
+                    readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                    readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                }
+            ]>;
+        };
+        namespace state_group {
+            namespace D {
+            }
+            type D = _T_Type_Node;
+        }
+        type state_group = _i_core._T_Dictionary<null, _T_Type_Node>;
+        namespace text {
+            namespace SG {
+                namespace global {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Globals.text_types.D;
+                }
+                type global = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>;
+                namespace local {
+                }
+                type local = _T_Text_Type;
+            }
+            type SG = readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type];
+        }
+        type text = _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>;
+        namespace type_parameter {
+            namespace Dictionary_Entry {
+            }
+            type Dictionary_Entry = _T_Type_Parameters.D;
+        }
+        type type_parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Parameters.D>;
+    }
+    type SG = readonly ['boolean', null] | readonly [
+        'component',
+        _i_core._T_State_Group<null, readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>
+    ] | readonly ['dictionary', _T_Dictionary] | readonly ['group', _T_Group] | readonly ['identifier value pair', _T_Type_Node] | readonly [
+        'list',
+        {
+            readonly 'node': _T_Type_Node;
+        }
+    ] | readonly ['nothing', null] | readonly [
+        'number',
+        _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type]>
+    ] | readonly ['optional', _T_Type_Node] | readonly [
+        'reference',
+        {
+            readonly 'referent': _T_Type_Node_Reference;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+                'selected',
+                {
+                    readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                    readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                }
+            ]>;
+        }
+    ] | readonly ['state group', _i_core._T_Dictionary<null, _T_Type_Node>] | readonly [
+        'text',
+        _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>
+    ] | readonly ['type parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Parameters.D>];
+}
+export declare namespace _T_Type_Node_Reference {
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+    namespace tail {
+        namespace L {
+            namespace SG {
+                type dictionary = null;
+                namespace group {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Group.D;
+                }
+                type group = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>;
+                type identifier_value_pair = null;
+                type list = null;
+                type optional = null;
+                namespace state_group {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Type_Node.SG.state_group.D;
+                }
+                type state_group = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+            type SG = readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>];
+        }
+        type L = _i_core._T_State_Group<null, readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>]>;
+    }
+    type tail = _i_core._T_List<null, _i_core._T_State_Group<null, readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>]>>;
+    namespace type_location {
+    }
+    type type_location = _T_Type_Reference;
+}
+export declare namespace _T_Type_Parameters {
+    type D = null;
+}
+export declare namespace _T_Type_Reference {
+    namespace location {
+        namespace SG {
+            namespace external {
+                namespace _import {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Imports.D;
+                }
+                type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                namespace _type {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Types.D;
+                }
+                type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+            type external = {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            };
+            namespace internal {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Types.D;
+            }
+            type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+        }
+        type SG = readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>];
+    }
+    type location = _i_core._T_State_Group<null, readonly [
+        'external',
+        {
+            readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+            readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+        }
+    ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>]>;
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+}
+export declare namespace _T_Type_Specification {
+    namespace schema {
+    }
+    type schema = _T_Schema_Tree;
+    namespace schema_path {
+        type L = string;
+    }
+    type schema_path = _i_core._T_List<null, string>;
+    type _type = string;
+}
+export declare namespace _T_Types {
+    namespace D {
+    }
+    type D = _T_Type;
+}
+export declare namespace Benchmark {
+    type dense = boolean;
+    namespace resulting_dictionary {
+        namespace Type {
+        }
+        type Type = _T_Dictionary;
+    }
+    type resulting_dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+    namespace selection {
+    }
+    type selection = _T_Guaranteed_Value_Selection;
+}
+export declare namespace Constraint {
+    namespace selection {
+    }
+    type selection = _T_Relative_Value_Selection;
+    namespace _type {
+        namespace SG {
+            namespace optional_value {
+                namespace selected_optional_value {
+                    namespace Type {
+                    }
+                    type Type = _T_Type_Node.SG.optional;
+                }
+                type selected_optional_value = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+            }
+            type optional_value = {
+                readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+            };
+            namespace state {
+                namespace selected_state_group {
+                    namespace Type {
+                    }
+                    type Type = _T_Type_Node.SG.state_group;
+                }
+                type selected_state_group = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                namespace state {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Type_Node.SG.state_group.D;
+                }
+                type state = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+            type state = {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            };
+        }
+        type SG = readonly [
+            'optional value',
+            {
+                readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+            }
+        ] | readonly [
+            'state',
+            {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+        ];
+    }
+    type _type = _i_core._T_State_Group<null, readonly [
+        'optional value',
+        {
+            readonly 'selected optional value': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.optional>;
+        }
+    ] | readonly [
+        'state',
+        {
+            readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+        }
+    ]>;
+}
+export declare namespace Dictionary {
+    namespace node {
+    }
+    type node = _T_Type_Node;
+    type ordered = boolean;
+}
+export declare namespace Globals {
+    namespace complexity {
+        namespace SG {
+            type constrained = null;
+            type unconstrained = null;
+        }
+        type SG = readonly ['constrained', null] | readonly ['unconstrained', null];
+    }
+    type complexity = _i_core._T_State_Group<null, readonly ['constrained', null] | readonly ['unconstrained', null]>;
+    namespace number_types {
+        namespace D {
+        }
+        type D = _T_Number_Type;
+    }
+    type number_types = _i_core._T_Dictionary<null, _T_Number_Type>;
+    namespace text_types {
+        namespace D {
+        }
+        type D = _T_Text_Type;
+    }
+    type text_types = _i_core._T_Dictionary<null, _T_Text_Type>;
+}
+export declare namespace Group {
+    namespace D {
+    }
+    type D = _T_Type_Node;
+}
+export declare namespace Guaranteed_Value_Selection {
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+    namespace start {
+        namespace SG {
+            namespace constraint {
+                namespace SG {
+                    namespace component {
+                        namespace constraint {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Property_Constraints.D;
+                        }
+                        type constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                    type component = {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    };
+                    namespace reference {
+                        namespace constraint {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Property_Constraints.D;
+                        }
+                        type constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                    type reference = {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    };
+                }
+                type SG = readonly [
+                    'component',
+                    {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                ] | readonly [
+                    'reference',
+                    {
+                        readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                ];
+            }
+            type constraint = _i_core._T_State_Group<null, readonly [
+                'component',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'reference',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ]>;
+            type linked_entry = null;
+            type list_cursor = null;
+            namespace option_constraint {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Option_Constraints.D;
+            }
+            type option_constraint = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>;
+            namespace parameter {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Signature_Parameters.values.D;
+            }
+            type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>;
+            namespace parent_sibling {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Node_Resolver_Group.D;
+            }
+            type parent_sibling = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            namespace result {
+                namespace SG {
+                    namespace list {
+                        namespace list_result {
+                            namespace Type {
+                            }
+                            type Type = _T_Node_Resolver.SG.list.result.O;
+                        }
+                        type list_result = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                    type list = {
+                        readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    };
+                    namespace optional_value {
+                        namespace optional_value {
+                            namespace Type {
+                            }
+                            type Type = _T_Node_Resolver.SG.optional;
+                        }
+                        type optional_value = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        namespace result {
+                        }
+                        type result = _T_Type_Reference;
+                    }
+                    type optional_value = {
+                        readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                    };
+                    namespace state_group {
+                        namespace property {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                        }
+                        type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        namespace result {
+                        }
+                        type result = _T_Type_Reference;
+                        namespace state_group {
+                            namespace Type {
+                            }
+                            type Type = _T_Node_Resolver.SG.state_group;
+                        }
+                        type state_group = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                    }
+                    type state_group = {
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                        readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                    };
+                }
+                type SG = readonly [
+                    'list',
+                    {
+                        readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    }
+                ] | readonly [
+                    'optional value',
+                    {
+                        readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                    }
+                ] | readonly [
+                    'state group',
+                    {
+                        readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                        readonly 'result': _T_Type_Reference;
+                        readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                    }
+                ];
+            }
+            type result = _i_core._T_State_Group<null, readonly [
+                'list',
+                {
+                    readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'optional value',
+                {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                }
+            ] | readonly [
+                'state group',
+                {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+            ]>;
+            namespace sibling {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Node_Resolver_Group.D;
+            }
+            type sibling = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+        }
+        type SG = readonly [
+            'constraint',
+            _i_core._T_State_Group<null, readonly [
+                'component',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'reference',
+                {
+                    readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ]>
+        ] | readonly ['linked entry', null] | readonly ['list cursor', null] | readonly ['option constraint', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['parent sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>] | readonly [
+            'result',
+            _i_core._T_State_Group<null, readonly [
+                'list',
+                {
+                    readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                }
+            ] | readonly [
+                'optional value',
+                {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                }
+            ] | readonly [
+                'state group',
+                {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+            ]>
+        ] | readonly ['sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>];
+    }
+    type start = _i_core._T_State_Group<null, readonly [
+        'constraint',
+        _i_core._T_State_Group<null, readonly [
+            'component',
+            {
+                readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ] | readonly [
+            'reference',
+            {
+                readonly 'constraint': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Property_Constraints.D>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ]>
+    ] | readonly ['linked entry', null] | readonly ['list cursor', null] | readonly ['option constraint', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Option_Constraints.D>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['parent sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>] | readonly [
+        'result',
+        _i_core._T_State_Group<null, readonly [
+            'list',
+            {
+                readonly 'list result': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.list.result.O>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+            }
+        ] | readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>
+    ] | readonly ['sibling', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>]>;
+    namespace tail {
+    }
+    type tail = _T_Relative_Value_Selection;
+}
+export declare namespace Imports {
+    namespace D {
+        namespace schema {
+            namespace Type {
+            }
+            type Type = _T_Schema;
+        }
+        type schema = _i_core._T_Derived_Reference<null, _T_Schema>;
+        namespace schema_set_child {
+            namespace Dictionary_Entry {
+            }
+            type Dictionary_Entry = _T_Schemas.D;
+        }
+        type schema_set_child = _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
+    }
+    type D = {
+        readonly 'schema': _i_core._T_Derived_Reference<null, _T_Schema>;
+        readonly 'schema set child': _i_core._T_Reference_To_Stacked_Dictionary_Entry<null, _T_Schemas.D>;
+    };
+}
+export declare namespace Lookup_Selection {
+    namespace resulting_dictionary {
+        namespace Type {
+        }
+        type Type = _T_Dictionary;
+    }
+    type resulting_dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+    namespace _type {
+        namespace SG {
+            namespace dictionary {
+                namespace selected_dictionary {
+                    namespace Type {
+                    }
+                    type Type = _T_Dictionary;
+                }
+                type selected_dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                namespace selection {
+                }
+                type selection = _T_Guaranteed_Value_Selection;
+            }
+            type dictionary = {
+                readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+            };
+            namespace not_circular_dependent_siblings {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type not_circular_dependent_siblings = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            namespace parameter {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Signature_Parameters.lookups.D;
+            }
+            type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>;
+            namespace possibly_circular_dependent_siblings {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type possibly_circular_dependent_siblings = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+        }
+        type SG = readonly [
+            'dictionary',
+            {
+                readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+            }
+        ] | readonly ['not circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>] | readonly ['possibly circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>];
+    }
+    type _type = _i_core._T_State_Group<null, readonly [
+        'dictionary',
+        {
+            readonly 'selected dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'selection': _T_Guaranteed_Value_Selection;
+        }
+    ] | readonly ['not circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.lookups.D>] | readonly ['possibly circular dependent siblings', _i_core._T_Derived_Reference<null, _T_Dictionary>]>;
+}
+export declare namespace Node_Resolver {
+    namespace SG {
+        type _boolean = null;
+        namespace component {
+            namespace _arguments {
+                namespace O {
+                    namespace lookups {
+                        namespace O {
+                            namespace D {
+                                namespace SG {
+                                    type empty_stack = null;
+                                    type not_set = null;
+                                    namespace selection {
+                                    }
+                                    type selection = _T_Lookup_Selection;
+                                    namespace stack {
+                                        namespace element {
+                                        }
+                                        type element = _T_Lookup_Selection;
+                                        namespace stack {
+                                        }
+                                        type stack = _T_Lookup_Selection;
+                                    }
+                                    type stack = {
+                                        readonly 'element': _T_Lookup_Selection;
+                                        readonly 'stack': _T_Lookup_Selection;
+                                    };
+                                }
+                                type SG = readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                                    'stack',
+                                    {
+                                        readonly 'element': _T_Lookup_Selection;
+                                        readonly 'stack': _T_Lookup_Selection;
+                                    }
+                                ];
+                            }
+                            type D = _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                                'stack',
+                                {
+                                    readonly 'element': _T_Lookup_Selection;
+                                    readonly 'stack': _T_Lookup_Selection;
+                                }
+                            ]>;
+                        }
+                        type O = _i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                            'stack',
+                            {
+                                readonly 'element': _T_Lookup_Selection;
+                                readonly 'stack': _T_Lookup_Selection;
+                            }
+                        ]>>;
+                    }
+                    type lookups = _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                        'stack',
+                        {
+                            readonly 'element': _T_Lookup_Selection;
+                            readonly 'stack': _T_Lookup_Selection;
+                        }
+                    ]>>>;
+                    namespace values {
+                        namespace O {
+                            namespace D {
+                                namespace SG {
+                                    namespace optional {
+                                    }
+                                    type optional = _T_Optional_Value_Initialization;
+                                    namespace parameter {
+                                        namespace Dictionary_Entry {
+                                        }
+                                        type Dictionary_Entry = _T_Signature_Parameters.values.D;
+                                    }
+                                    type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>;
+                                    namespace required {
+                                    }
+                                    type required = _T_Guaranteed_Value_Selection;
+                                }
+                                type SG = readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection];
+                            }
+                            type D = _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>;
+                        }
+                        type O = _i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>;
+                    }
+                    type values = _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+                }
+                type O = {
+                    readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                        'stack',
+                        {
+                            readonly 'element': _T_Lookup_Selection;
+                            readonly 'stack': _T_Lookup_Selection;
+                        }
+                    ]>>>;
+                    readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+                };
+            }
+            type _arguments = _pt.Optional_Value<{
+                readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                    'stack',
+                    {
+                        readonly 'element': _T_Lookup_Selection;
+                        readonly 'stack': _T_Lookup_Selection;
+                    }
+                ]>>>;
+                readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+            }>;
+            namespace constraints {
+            }
+            type constraints = _T_Property_Constraints;
+            namespace location {
+                namespace SG {
+                    namespace external {
+                        namespace _import {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Imports.D;
+                        }
+                        type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                        namespace _type {
+                            namespace Dictionary_Entry {
+                            }
+                            type Dictionary_Entry = _T_Signatures.D;
+                        }
+                        type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                    }
+                    type external = {
+                        readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                        readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                    };
+                    namespace internal {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Signatures.D;
+                    }
+                    type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+                type SG = readonly [
+                    'external',
+                    {
+                        readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                        readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                    }
+                ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>];
+            }
+            type location = _i_core._T_State_Group<null, readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+            namespace signature {
+                namespace Type {
+                }
+                type Type = _T_Signatures.D;
+            }
+            type signature = _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        }
+        type component = {
+            readonly 'arguments': _pt.Optional_Value<{
+                readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                    'stack',
+                    {
+                        readonly 'element': _T_Lookup_Selection;
+                        readonly 'stack': _T_Lookup_Selection;
+                    }
+                ]>>>;
+                readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+            }>;
+            readonly 'constraints': _T_Property_Constraints;
+            readonly 'location': _i_core._T_State_Group<null, readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+            readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        };
+        namespace dictionary {
+            namespace benchmark {
+                namespace O {
+                }
+                type O = _T_Benchmark;
+            }
+            type benchmark = _pt.Optional_Value<_T_Benchmark>;
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            namespace resolver {
+            }
+            type resolver = _T_Node_Resolver;
+        }
+        type dictionary = {
+            readonly 'benchmark': _pt.Optional_Value<_T_Benchmark>;
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'resolver': _T_Node_Resolver;
+        };
+        namespace group {
+        }
+        type group = _T_Node_Resolver_Group;
+        namespace identifier_value_pair {
+        }
+        type identifier_value_pair = _T_Node_Resolver;
+        namespace list {
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Type_Node.SG.list;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+            namespace resolver {
+            }
+            type resolver = _T_Node_Resolver;
+            namespace result {
+                namespace O {
+                }
+                type O = _T_Node_Resolver_List_Result;
+            }
+            type result = _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+        }
+        type list = {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+            readonly 'resolver': _T_Node_Resolver;
+            readonly 'result': _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+        };
+        type nothing = null;
+        type _number = null;
+        namespace optional {
+            namespace constraints {
+            }
+            type constraints = _T_Option_Constraints;
+            namespace resolver {
+            }
+            type resolver = _T_Node_Resolver;
+        }
+        type optional = {
+            readonly 'constraints': _T_Option_Constraints;
+            readonly 'resolver': _T_Node_Resolver;
+        };
+        namespace reference {
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Type_Node.SG.reference;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            namespace _type {
+                namespace SG {
+                    namespace derived {
+                        namespace value {
+                        }
+                        type value = _T_Guaranteed_Value_Selection;
+                    }
+                    type derived = {
+                        readonly 'value': _T_Guaranteed_Value_Selection;
+                    };
+                    namespace selected {
+                        namespace constraints {
+                        }
+                        type constraints = _T_Property_Constraints;
+                        namespace definition {
+                            namespace Type {
+                            }
+                            type Type = _T_Type_Node.SG.reference._type.SG.selected;
+                        }
+                        type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                        namespace lookup {
+                        }
+                        type lookup = _T_Lookup_Selection;
+                    }
+                    type selected = {
+                        readonly 'constraints': _T_Property_Constraints;
+                        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                        readonly 'lookup': _T_Lookup_Selection;
+                    };
+                }
+                type SG = readonly [
+                    'derived',
+                    {
+                        readonly 'value': _T_Guaranteed_Value_Selection;
+                    }
+                ] | readonly [
+                    'selected',
+                    {
+                        readonly 'constraints': _T_Property_Constraints;
+                        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                        readonly 'lookup': _T_Lookup_Selection;
+                    }
+                ];
+            }
+            type _type = _i_core._T_State_Group<null, readonly [
+                'derived',
+                {
+                    readonly 'value': _T_Guaranteed_Value_Selection;
+                }
+            ] | readonly [
+                'selected',
+                {
+                    readonly 'constraints': _T_Property_Constraints;
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                    readonly 'lookup': _T_Lookup_Selection;
+                }
+            ]>;
+        }
+        type reference = {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            readonly 'type': _i_core._T_State_Group<null, readonly [
+                'derived',
+                {
+                    readonly 'value': _T_Guaranteed_Value_Selection;
+                }
+            ] | readonly [
+                'selected',
+                {
+                    readonly 'constraints': _T_Property_Constraints;
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                    readonly 'lookup': _T_Lookup_Selection;
+                }
+            ]>;
+        };
+        namespace state_group {
+            namespace definition {
+                namespace Type {
+                }
+                type Type = _T_Type_Node.SG.state_group;
+            }
+            type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            namespace states {
+                namespace D {
+                    namespace constraints {
+                    }
+                    type constraints = _T_Option_Constraints;
+                    namespace resolver {
+                    }
+                    type resolver = _T_Node_Resolver;
+                }
+                type D = {
+                    readonly 'constraints': _T_Option_Constraints;
+                    readonly 'resolver': _T_Node_Resolver;
+                };
+            }
+            type states = _i_core._T_Dictionary<null, {
+                readonly 'constraints': _T_Option_Constraints;
+                readonly 'resolver': _T_Node_Resolver;
+            }>;
+        }
+        type state_group = {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'states': _i_core._T_Dictionary<null, {
+                readonly 'constraints': _T_Option_Constraints;
+                readonly 'resolver': _T_Node_Resolver;
+            }>;
+        };
+        type text = null;
+        type type_parameter = null;
+    }
+    type SG = readonly ['boolean', null] | readonly [
+        'component',
+        {
+            readonly 'arguments': _pt.Optional_Value<{
+                readonly 'lookups': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['empty stack', null] | readonly ['not set', null] | readonly ['selection', _T_Lookup_Selection] | readonly [
+                    'stack',
+                    {
+                        readonly 'element': _T_Lookup_Selection;
+                        readonly 'stack': _T_Lookup_Selection;
+                    }
+                ]>>>;
+                readonly 'values': _pt.Optional_Value<_i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['optional', _T_Optional_Value_Initialization] | readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly ['required', _T_Guaranteed_Value_Selection]>>>;
+            }>;
+            readonly 'constraints': _T_Property_Constraints;
+            readonly 'location': _i_core._T_State_Group<null, readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>]>;
+            readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        }
+    ] | readonly [
+        'dictionary',
+        {
+            readonly 'benchmark': _pt.Optional_Value<_T_Benchmark>;
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'resolver': _T_Node_Resolver;
+        }
+    ] | readonly ['group', _T_Node_Resolver_Group] | readonly ['identifier value pair', _T_Node_Resolver] | readonly [
+        'list',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.list>;
+            readonly 'resolver': _T_Node_Resolver;
+            readonly 'result': _pt.Optional_Value<_T_Node_Resolver_List_Result>;
+        }
+    ] | readonly ['nothing', null] | readonly ['number', null] | readonly [
+        'optional',
+        {
+            readonly 'constraints': _T_Option_Constraints;
+            readonly 'resolver': _T_Node_Resolver;
+        }
+    ] | readonly [
+        'reference',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            readonly 'type': _i_core._T_State_Group<null, readonly [
+                'derived',
+                {
+                    readonly 'value': _T_Guaranteed_Value_Selection;
+                }
+            ] | readonly [
+                'selected',
+                {
+                    readonly 'constraints': _T_Property_Constraints;
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference._type.SG.selected>;
+                    readonly 'lookup': _T_Lookup_Selection;
+                }
+            ]>;
+        }
+    ] | readonly [
+        'state group',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'states': _i_core._T_Dictionary<null, {
+                readonly 'constraints': _T_Option_Constraints;
+                readonly 'resolver': _T_Node_Resolver;
+            }>;
+        }
+    ] | readonly ['text', null] | readonly ['type parameter', null];
+}
+export declare namespace Node_Resolver_Group {
+    namespace D {
+        namespace definition {
+            namespace Type {
+            }
+            type Type = _T_Group.D;
+        }
+        type definition = _i_core._T_Derived_Reference<null, _T_Group.D>;
+        namespace resolver {
+        }
+        type resolver = _T_Node_Resolver;
+    }
+    type D = {
+        readonly 'definition': _i_core._T_Derived_Reference<null, _T_Group.D>;
+        readonly 'resolver': _T_Node_Resolver;
+    };
+}
+export declare namespace Node_Resolver_List_Result {
+}
+export declare namespace Number_Type {
+    namespace precision {
+        namespace SG {
+            namespace approximation {
+                type significant_digits = number;
+            }
+            type approximation = {
+                readonly 'significant digits': number;
+            };
+            namespace exact {
+                namespace decimal_separator_offset {
+                    type O = number;
+                }
+                type decimal_separator_offset = _pt.Optional_Value<number>;
+                namespace _type {
+                    namespace SG {
+                        type integer = null;
+                        type natural = null;
+                        type positive_natural = null;
+                    }
+                    type SG = readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null];
+                }
+                type _type = _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+            }
+            type exact = {
+                readonly 'decimal separator offset': _pt.Optional_Value<number>;
+                readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+            };
+        }
+        type SG = readonly [
+            'approximation',
+            {
+                readonly 'significant digits': number;
+            }
+        ] | readonly [
+            'exact',
+            {
+                readonly 'decimal separator offset': _pt.Optional_Value<number>;
+                readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+            }
+        ];
+    }
+    type precision = _i_core._T_State_Group<null, readonly [
+        'approximation',
+        {
+            readonly 'significant digits': number;
+        }
+    ] | readonly [
+        'exact',
+        {
+            readonly 'decimal separator offset': _pt.Optional_Value<number>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['integer', null] | readonly ['natural', null] | readonly ['positive natural', null]>;
+        }
+    ]>;
+}
+export declare namespace Option_Constraints {
+    namespace D {
+        namespace SG {
+            namespace assert_is_set {
+            }
+            type assert_is_set = _T_Possible_Value_Selection;
+            namespace state {
+                namespace selected_state_group {
+                    namespace Type {
+                    }
+                    type Type = _T_Type_Node.SG.state_group;
+                }
+                type selected_state_group = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                namespace selection {
+                }
+                type selection = _T_Guaranteed_Value_Selection;
+                namespace state {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Type_Node.SG.state_group.D;
+                }
+                type state = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+            type state = {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            };
+        }
+        type SG = readonly ['assert is set', _T_Possible_Value_Selection] | readonly [
+            'state',
+            {
+                readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+                readonly 'selection': _T_Guaranteed_Value_Selection;
+                readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+        ];
+    }
+    type D = _i_core._T_State_Group<null, readonly ['assert is set', _T_Possible_Value_Selection] | readonly [
+        'state',
+        {
+            readonly 'selected state group': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.state_group>;
+            readonly 'selection': _T_Guaranteed_Value_Selection;
+            readonly 'state': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+        }
+    ]>;
+}
+export declare namespace Optional_Value_Initialization {
+    namespace SG {
+        type not_set = null;
+        namespace selection {
+        }
+        type selection = _T_Possible_Value_Selection;
+        namespace _set {
+        }
+        type _set = _T_Guaranteed_Value_Selection;
+    }
+    type SG = readonly ['not set', null] | readonly ['selection', _T_Possible_Value_Selection] | readonly ['set', _T_Guaranteed_Value_Selection];
+}
+export declare namespace Possible_Value_Selection {
+    namespace SG {
+        namespace parameter {
+            namespace Dictionary_Entry {
+            }
+            type Dictionary_Entry = _T_Signature_Parameters.values.D;
+        }
+        type parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>;
+        namespace result {
+            namespace SG {
+                namespace optional_value {
+                    namespace optional_value {
+                        namespace Type {
+                        }
+                        type Type = _T_Node_Resolver.SG.optional;
+                    }
+                    type optional_value = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    namespace property {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                    }
+                    type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    namespace result {
+                    }
+                    type result = _T_Type_Reference;
+                }
+                type optional_value = {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                };
+                namespace state_group {
+                    namespace property {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Node_Resolver_Group.D;
+                    }
+                    type property = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    namespace result {
+                    }
+                    type result = _T_Type_Reference;
+                    namespace state_group {
+                        namespace Type {
+                        }
+                        type Type = _T_Node_Resolver.SG.state_group;
+                    }
+                    type state_group = _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+                type state_group = {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                };
+            }
+            type SG = readonly [
+                'optional value',
+                {
+                    readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                }
+            ] | readonly [
+                'state group',
+                {
+                    readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                    readonly 'result': _T_Type_Reference;
+                    readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+                }
+            ];
+        }
+        type result = _i_core._T_State_Group<null, readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>;
+    }
+    type SG = readonly ['parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signature_Parameters.values.D>] | readonly [
+        'result',
+        _i_core._T_State_Group<null, readonly [
+            'optional value',
+            {
+                readonly 'optional value': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.optional>;
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+            }
+        ] | readonly [
+            'state group',
+            {
+                readonly 'property': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Node_Resolver_Group.D>;
+                readonly 'result': _T_Type_Reference;
+                readonly 'state group': _i_core._T_Derived_Reference<null, _T_Node_Resolver.SG.state_group>;
+            }
+        ]>
+    ];
+}
+export declare namespace Presence {
+    namespace SG {
+        type optional = null;
+        type required = null;
+    }
+    type SG = readonly ['optional', null] | readonly ['required', null];
+}
+export declare namespace Property_Constraint {
+    namespace constraint {
+    }
+    type constraint = _T_Constraint;
+    namespace start {
+        namespace SG {
+            type property = null;
+            namespace sibling {
+            }
+            type sibling = _T_Reference_To_Property_Constraint;
+        }
+        type SG = readonly ['property', null] | readonly ['sibling', _T_Reference_To_Property_Constraint];
+    }
+    type start = _i_core._T_State_Group<null, readonly ['property', null] | readonly ['sibling', _T_Reference_To_Property_Constraint]>;
+}
+export declare namespace Property_Constraints {
+    namespace D {
+    }
+    type D = _T_Property_Constraint;
+}
+export declare namespace Reference_To_Property_Constraint {
+    namespace Dictionary_Entry {
+    }
+    type Dictionary_Entry = _T_Property_Constraints.D;
+}
+export declare namespace Relative_Value_Selection {
+    namespace path {
+        namespace L {
+            namespace SG {
+                type component = null;
+                namespace group {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Group.D;
+                }
+                type group = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>;
+                namespace reference {
+                    namespace definition {
+                        namespace Type {
+                        }
+                        type Type = _T_Type_Node.SG.reference;
+                    }
+                    type definition = _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+                }
+                type reference = {
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+                };
+            }
+            type SG = readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+                'reference',
+                {
+                    readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+                }
+            ];
+        }
+        type L = _i_core._T_State_Group<null, readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+            'reference',
+            {
+                readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+            }
+        ]>;
+    }
+    type path = _i_core._T_List<null, _i_core._T_State_Group<null, readonly ['component', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly [
+        'reference',
+        {
+            readonly 'definition': _i_core._T_Derived_Reference<null, _T_Type_Node.SG.reference>;
+        }
+    ]>>;
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+}
+export declare namespace Resolve_Logic {
+    namespace resolvers {
+    }
+    type resolvers = _T_Resolvers;
+    namespace signatures {
+        namespace types {
+        }
+        type types = _T_Signatures;
+    }
+    type signatures = {
+        readonly 'types': _T_Signatures;
+    };
+}
+export declare namespace Resolvers {
+    namespace D {
+        namespace signature {
+            namespace Type {
+            }
+            type Type = _T_Signatures.D;
+        }
+        type signature = _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        namespace type_resolver {
+        }
+        type type_resolver = _T_Node_Resolver;
+    }
+    type D = {
+        readonly 'signature': _i_core._T_Derived_Reference<null, _T_Signatures.D>;
+        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 Schema_Tree {
+    namespace SG {
+        namespace schema {
+        }
+        type schema = _T_Schema;
+        namespace _set {
+        }
+        type _set = _T_Schemas;
+    }
+    type SG = readonly ['schema', _T_Schema] | readonly ['set', _T_Schemas];
+}
+export declare namespace Schemas {
+    namespace D {
+    }
+    type D = _T_Schema_Tree;
+}
+export declare namespace Signature {
+    namespace parameters {
+        namespace SG {
+            namespace local {
+            }
+            type local = _T_Signature_Parameters;
+            namespace same_as {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Signatures.D;
+            }
+            type same_as = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>;
+        }
+        type SG = readonly ['local', _T_Signature_Parameters] | readonly ['same as', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Signatures.D>];
+    }
+    type 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>]>;
+    namespace resolved_parameters {
+        namespace Type {
+        }
+        type Type = _T_Signature_Parameters;
+    }
+    type resolved_parameters = _i_core._T_Derived_Reference<null, _T_Signature_Parameters>;
+    namespace _type {
+        namespace Type {
+        }
+        type Type = _T_Type;
+    }
+    type _type = _i_core._T_Derived_Reference<null, _T_Type>;
+}
+export declare namespace Signature_Parameters {
+    namespace lookups {
+        namespace D {
+            namespace dictionary {
+                namespace Type {
+                }
+                type Type = _T_Dictionary;
+            }
+            type dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            namespace presence {
+            }
+            type presence = _T_Presence;
+            namespace referent {
+            }
+            type referent = _T_Type_Reference;
+            namespace _type {
+                namespace SG {
+                    type acyclic = null;
+                    type cyclic = null;
+                    type stack = null;
+                }
+                type SG = readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null];
+            }
+            type _type = _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+        }
+        type D = {
+            readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+            readonly 'presence': _T_Presence;
+            readonly 'referent': _T_Type_Reference;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+        };
+    }
+    type lookups = _i_core._T_Dictionary<null, {
+        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+        readonly 'presence': _T_Presence;
+        readonly 'referent': _T_Type_Reference;
+        readonly 'type': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+    }>;
+    namespace values {
+        namespace D {
+            namespace data_type {
+            }
+            type data_type = _T_Type_Reference;
+            namespace presence {
+            }
+            type presence = _T_Presence;
+        }
+        type D = {
+            readonly 'data type': _T_Type_Reference;
+            readonly 'presence': _T_Presence;
+        };
+    }
+    type values = _i_core._T_Dictionary<null, {
+        readonly 'data type': _T_Type_Reference;
+        readonly 'presence': _T_Presence;
+    }>;
+}
+export declare namespace Signatures {
+    namespace D {
+    }
+    type D = _T_Signature;
+}
+export declare namespace Text_Type {
+    namespace _type {
+        namespace SG {
+            type multi_line = null;
+            type single_line = null;
+        }
+        type SG = readonly ['multi line', null] | readonly ['single line', null];
+    }
+    type _type = _i_core._T_State_Group<null, readonly ['multi line', null] | readonly ['single line', null]>;
+}
+export declare namespace Type {
+    namespace node {
+    }
+    type node = _T_Type_Node;
+    namespace type_parameters {
+    }
+    type type_parameters = _T_Type_Parameters;
+}
+export declare namespace Type_Node {
+    namespace SG {
+        type _boolean = null;
+        namespace component {
+            namespace SG {
+                namespace external {
+                    namespace _import {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Imports.D;
+                    }
+                    type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    namespace _type {
+                        namespace Dictionary_Entry {
+                        }
+                        type Dictionary_Entry = _T_Types.D;
+                    }
+                    type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                }
+                type external = {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                };
+                namespace internal {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Types.D;
+                }
+                type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                namespace internal_cyclic {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Types.D;
+                }
+                type internal_cyclic = _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>;
+            }
+            type SG = readonly [
+                'external',
+                {
+                    readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                    readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+                }
+            ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>];
+        }
+        type component = _i_core._T_State_Group<null, readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>;
+        namespace dictionary {
+        }
+        type dictionary = _T_Dictionary;
+        namespace group {
+        }
+        type group = _T_Group;
+        namespace identifier_value_pair {
+        }
+        type identifier_value_pair = _T_Type_Node;
+        namespace list {
+            namespace node {
+            }
+            type node = _T_Type_Node;
+        }
+        type list = {
+            readonly 'node': _T_Type_Node;
+        };
+        type nothing = null;
+        namespace _number {
+            namespace SG {
+                namespace global {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Globals.number_types.D;
+                }
+                type global = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>;
+                namespace local {
+                }
+                type local = _T_Number_Type;
+            }
+            type SG = readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type];
+        }
+        type _number = _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type]>;
+        namespace optional {
+        }
+        type optional = _T_Type_Node;
+        namespace reference {
+            namespace referent {
+            }
+            type referent = _T_Type_Node_Reference;
+            namespace _type {
+                namespace SG {
+                    type derived = null;
+                    namespace selected {
+                        namespace dependency {
+                            namespace SG {
+                                type acyclic = null;
+                                type cyclic = null;
+                                type stack = null;
+                            }
+                            type SG = readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null];
+                        }
+                        type dependency = _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                        namespace dictionary {
+                            namespace Type {
+                            }
+                            type Type = _T_Dictionary;
+                        }
+                        type dictionary = _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                    }
+                    type selected = {
+                        readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                    };
+                }
+                type SG = readonly ['derived', null] | readonly [
+                    'selected',
+                    {
+                        readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                        readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                    }
+                ];
+            }
+            type _type = _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+                'selected',
+                {
+                    readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                    readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                }
+            ]>;
+        }
+        type reference = {
+            readonly 'referent': _T_Type_Node_Reference;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+                'selected',
+                {
+                    readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                    readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                }
+            ]>;
+        };
+        namespace state_group {
+            namespace D {
+            }
+            type D = _T_Type_Node;
+        }
+        type state_group = _i_core._T_Dictionary<null, _T_Type_Node>;
+        namespace text {
+            namespace SG {
+                namespace global {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Globals.text_types.D;
+                }
+                type global = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>;
+                namespace local {
+                }
+                type local = _T_Text_Type;
+            }
+            type SG = readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type];
+        }
+        type text = _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>;
+        namespace type_parameter {
+            namespace Dictionary_Entry {
+            }
+            type Dictionary_Entry = _T_Type_Parameters.D;
+        }
+        type type_parameter = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Parameters.D>;
+    }
+    type SG = readonly ['boolean', null] | readonly [
+        'component',
+        _i_core._T_State_Group<null, readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>] | readonly ['internal cyclic', _i_core._T_Reference_To_Circular_Dependent_Sibling<null, _T_Types.D>]>
+    ] | readonly ['dictionary', _T_Dictionary] | readonly ['group', _T_Group] | readonly ['identifier value pair', _T_Type_Node] | readonly [
+        'list',
+        {
+            readonly 'node': _T_Type_Node;
+        }
+    ] | readonly ['nothing', null] | readonly [
+        'number',
+        _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.number_types.D>] | readonly ['local', _T_Number_Type]>
+    ] | readonly ['optional', _T_Type_Node] | readonly [
+        'reference',
+        {
+            readonly 'referent': _T_Type_Node_Reference;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['derived', null] | readonly [
+                'selected',
+                {
+                    readonly 'dependency': _i_core._T_State_Group<null, readonly ['acyclic', null] | readonly ['cyclic', null] | readonly ['stack', null]>;
+                    readonly 'dictionary': _i_core._T_Derived_Reference<null, _T_Dictionary>;
+                }
+            ]>;
+        }
+    ] | readonly ['state group', _i_core._T_Dictionary<null, _T_Type_Node>] | readonly [
+        'text',
+        _i_core._T_State_Group<null, readonly ['global', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Globals.text_types.D>] | readonly ['local', _T_Text_Type]>
+    ] | readonly ['type parameter', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Parameters.D>];
+}
+export declare namespace Type_Node_Reference {
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+    namespace tail {
+        namespace L {
+            namespace SG {
+                type dictionary = null;
+                namespace group {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Group.D;
+                }
+                type group = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>;
+                type identifier_value_pair = null;
+                type list = null;
+                type optional = null;
+                namespace state_group {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Type_Node.SG.state_group.D;
+                }
+                type state_group = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>;
+            }
+            type SG = readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>];
+        }
+        type L = _i_core._T_State_Group<null, readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>]>;
+    }
+    type tail = _i_core._T_List<null, _i_core._T_State_Group<null, readonly ['dictionary', null] | readonly ['group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Group.D>] | readonly ['identifier value pair', null] | readonly ['list', null] | readonly ['optional', null] | readonly ['state group', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Type_Node.SG.state_group.D>]>>;
+    namespace type_location {
+    }
+    type type_location = _T_Type_Reference;
+}
+export declare namespace Type_Parameters {
+    type D = null;
+}
+export declare namespace Type_Reference {
+    namespace location {
+        namespace SG {
+            namespace external {
+                namespace _import {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Imports.D;
+                }
+                type _import = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                namespace _type {
+                    namespace Dictionary_Entry {
+                    }
+                    type Dictionary_Entry = _T_Types.D;
+                }
+                type _type = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+            type external = {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            };
+            namespace internal {
+                namespace Dictionary_Entry {
+                }
+                type Dictionary_Entry = _T_Types.D;
+            }
+            type internal = _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+        }
+        type SG = readonly [
+            'external',
+            {
+                readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+                readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+            }
+        ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>];
+    }
+    type location = _i_core._T_State_Group<null, readonly [
+        'external',
+        {
+            readonly 'import': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Imports.D>;
+            readonly 'type': _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>;
+        }
+    ] | readonly ['internal', _i_core._T_Reference_To_Normal_Dictionary_Entry<null, _T_Types.D>]>;
+    namespace resulting_node {
+        namespace Type {
+        }
+        type Type = _T_Type_Node;
+    }
+    type resulting_node = _i_core._T_Derived_Reference<null, _T_Type_Node>;
+}
+export declare namespace Type_Specification {
+    namespace schema {
+    }
+    type schema = _T_Schema_Tree;
+    namespace schema_path {
+        type L = string;
+    }
+    type schema_path = _i_core._T_List<null, string>;
+    type _type = string;
+}
+export declare namespace Types {
+    namespace D {
+    }
+    type D = _T_Type;
+}