typia 13.0.0-dev.20260430 → 13.0.0-dev.20260502-2

package/native/core/programmers/notations/NotationGeneralProgrammer.go

@@ -1,18 +1,18 @@
 package notations
 
 import (
-	"fmt"
-	"strings"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
-	nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  "fmt"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type notationGeneralProgrammerNamespace struct{}
@@ -20,28 +20,28 @@ type notationGeneralProgrammerNamespace struct{}
 var NotationGeneralProgrammer = notationGeneralProgrammerNamespace{}
 
 type NotationGeneralProgrammer_IRename struct {
-	Name string
-	Func func(str string) string
+  Name string
+  Func func(str string) string
 }
 
 type NotationGeneralProgrammer_IProps struct {
-	nativecontext.IProgrammerProps
-	Rename NotationGeneralProgrammer_IRename
+  nativecontext.IProgrammerProps
+  Rename NotationGeneralProgrammer_IRename
 }
 
 type NotationGeneralProgrammer_ReturnTypeProps struct {
-	Rename  NotationGeneralProgrammer_IRename
-	Context nativecontext.ITypiaContext
-	Type    string
+  Rename  NotationGeneralProgrammer_IRename
+  Context nativecontext.ITypiaContext
+  Type    string
 }
 
 type NotationGeneralProgrammer_DecomposeProps struct {
-	Rename    NotationGeneralProgrammer_IRename
-	Validated bool
-	Context   nativecontext.ITypiaContext
-	Functor   *nativehelpers.FunctionProgrammer
-	Type      *shimchecker.Type
-	Name      *string
+  Rename    NotationGeneralProgrammer_IRename
+  Validated bool
+  Context   nativecontext.ITypiaContext
+  Functor   *nativehelpers.FunctionProgrammer
+  Type      *shimchecker.Type
+  Name      *string
 }
 
 const notationGeneralProgrammer_PREFIX = "_c"
@@ -49,1224 +49,1224 @@ const notationGeneralProgrammer_PREFIX = "_c"
 var notationGeneralProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (notationGeneralProgrammerNamespace) ReturnType(props NotationGeneralProgrammer_ReturnTypeProps) *shimast.Node {
-	return notationGeneralProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
-		File: "typia",
-		Name: notationGeneralProgrammer_capitalize(props.Rename.Name) + "Case",
-		Arguments: []*shimast.TypeNode{
-			notationGeneralProgrammer_factory.NewTypeReferenceNode(notationGeneralProgrammer_factory.NewIdentifier(props.Type), nil),
-		},
-	})
+  return notationGeneralProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+    File: "typia",
+    Name: notationGeneralProgrammer_capitalize(props.Rename.Name) + "Case",
+    Arguments: []*shimast.TypeNode{
+      notationGeneralProgrammer_factory.NewTypeReferenceNode(notationGeneralProgrammer_factory.NewIdentifier(props.Type), nil),
+    },
+  })
 }
 
 func (notationGeneralProgrammerNamespace) Decompose(props NotationGeneralProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-	config := notationGeneralProgrammer_configure(struct {
-		Rename  NotationGeneralProgrammer_IRename
-		Context nativecontext.ITypiaContext
-		Functor *nativehelpers.FunctionProgrammer
-	}{Rename: props.Rename, Context: props.Context, Functor: props.Functor})
-	if props.Validated == false {
-		config.Addition = func(collection *schemametadata.MetadataCollection) []*shimast.Node {
-			return nativeprogrammers.IsProgrammer.Write_function_statements(nativeprogrammers.IsProgrammer_WriteFunctionStatementsProps{
-				Context:    props.Context,
-				Functor:    props.Functor,
-				Collection: collection,
-			})
-		}
-	}
-	composed := nativeinternal.FeatureProgrammer.Compose(nativeinternal.FeatureProgrammer_ComposeProps{
-		Context: props.Context,
-		Config:  config,
-		Functor: props.Functor,
-		Type:    props.Type,
-		Name:    props.Name,
-	})
-	typeName := notationGeneralProgrammer_type_name(props.Context, props.Type, props.Name)
-	return nativeinternal.FeatureProgrammer_IDecomposed{
-		Functions:  composed.Functions,
-		Statements: composed.Statements,
-		Arrow: notationGeneralProgrammer_factory.NewArrowFunction(
-			nil,
-			nil,
-			notationGeneralProgrammer_factory.NewNodeList(composed.Parameters),
-			NotationGeneralProgrammer.ReturnType(NotationGeneralProgrammer_ReturnTypeProps{
-				Rename:  props.Rename,
-				Context: props.Context,
-				Type:    typeName,
-			}),
-			nil,
-			notationGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			composed.Body,
-		),
-	}
+  config := notationGeneralProgrammer_configure(struct {
+    Rename  NotationGeneralProgrammer_IRename
+    Context nativecontext.ITypiaContext
+    Functor *nativehelpers.FunctionProgrammer
+  }{Rename: props.Rename, Context: props.Context, Functor: props.Functor})
+  if props.Validated == false {
+    config.Addition = func(collection *schemametadata.MetadataCollection) []*shimast.Node {
+      return nativeprogrammers.IsProgrammer.Write_function_statements(nativeprogrammers.IsProgrammer_WriteFunctionStatementsProps{
+        Context:    props.Context,
+        Functor:    props.Functor,
+        Collection: collection,
+      })
+    }
+  }
+  composed := nativeinternal.FeatureProgrammer.Compose(nativeinternal.FeatureProgrammer_ComposeProps{
+    Context: props.Context,
+    Config:  config,
+    Functor: props.Functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  typeName := notationGeneralProgrammer_type_name(props.Context, props.Type, props.Name)
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  composed.Functions,
+    Statements: composed.Statements,
+    Arrow: notationGeneralProgrammer_factory.NewArrowFunction(
+      nil,
+      nil,
+      notationGeneralProgrammer_factory.NewNodeList(composed.Parameters),
+      NotationGeneralProgrammer.ReturnType(NotationGeneralProgrammer_ReturnTypeProps{
+        Rename:  props.Rename,
+        Context: props.Context,
+        Type:    typeName,
+      }),
+      nil,
+      notationGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      composed.Body,
+    ),
+  }
 }
 
 func (notationGeneralProgrammerNamespace) Write(props NotationGeneralProgrammer_IProps) *shimast.Node {
-	functor := nativehelpers.NewFunctionProgrammer(notationGeneralProgrammer_method_text(props.Modulo))
-	result := NotationGeneralProgrammer.Decompose(NotationGeneralProgrammer_DecomposeProps{
-		Rename:    props.Rename,
-		Context:   props.Context,
-		Functor:   functor,
-		Type:      props.Type,
-		Name:      props.Name,
-		Validated: true,
-	})
-	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-		Functor: functor,
-		Modulo:  props.Modulo,
-		Result:  result,
-	})
+  functor := nativehelpers.NewFunctionProgrammer(notationGeneralProgrammer_method_text(props.Modulo))
+  result := NotationGeneralProgrammer.Decompose(NotationGeneralProgrammer_DecomposeProps{
+    Rename:    props.Rename,
+    Context:   props.Context,
+    Functor:   functor,
+    Type:      props.Type,
+    Name:      props.Name,
+    Validated: true,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Functor: functor,
+    Modulo:  props.Modulo,
+    Result:  result,
+  })
 }
 
 func notationGeneralProgrammer_write_array_functions(props struct {
-	Config     nativeinternal.FeatureProgrammer_IConfig
-	Functor    *nativehelpers.FunctionProgrammer
-	Collection *schemametadata.MetadataCollection
+  Config     nativeinternal.FeatureProgrammer_IConfig
+  Functor    *nativehelpers.FunctionProgrammer
+  Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-	output := []*shimast.Node{}
-	for i, typ := range props.Collection.Arrays() {
-		if typ.Recursive == false {
-			continue
-		}
-		output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-			Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
-			Value: notationGeneralProgrammer_factory.NewArrowFunction(
-				nil,
-				nil,
-				notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
-					Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-					Type:   nativefactories.TypeFactory.Keyword("any"),
-					Input:  notationGeneralProgrammer_factory.NewIdentifier("input"),
-				})),
-				nativefactories.TypeFactory.Keyword("any"),
-				nil,
-				notationGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-				notationGeneralProgrammer_decode_array_inline(notationGeneralProgrammer_decodeArrayProps{
-					Config:  props.Config,
-					Functor: props.Functor,
-					Input:   notationGeneralProgrammer_factory.NewIdentifier("input"),
-					Array: schemametadata.MetadataArray_create(schemametadata.MetadataArray{
-						Type: typ,
-						Tags: [][]schemametadata.IMetadataTypeTag{},
-					}),
-					Explore: nativeinternal.FeatureProgrammer_IExplore{
-						Tracable: props.Config.Trace,
-						Source:   "function",
-						From:     "array",
-						Postfix:  "",
-					},
-				}),
-			),
-		}))
-	}
-	return output
+  output := []*shimast.Node{}
+  for i, typ := range props.Collection.Arrays() {
+    if typ.Recursive == false {
+      continue
+    }
+    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Value: notationGeneralProgrammer_factory.NewArrowFunction(
+        nil,
+        nil,
+        notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
+          Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+          Type:   nativefactories.TypeFactory.Keyword("any"),
+          Input:  notationGeneralProgrammer_factory.NewIdentifier("input"),
+        })),
+        nativefactories.TypeFactory.Keyword("any"),
+        nil,
+        notationGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+        notationGeneralProgrammer_decode_array_inline(notationGeneralProgrammer_decodeArrayProps{
+          Config:  props.Config,
+          Functor: props.Functor,
+          Input:   notationGeneralProgrammer_factory.NewIdentifier("input"),
+          Array: schemametadata.MetadataArray_create(schemametadata.MetadataArray{
+            Type: typ,
+            Tags: [][]schemametadata.IMetadataTypeTag{},
+          }),
+          Explore: nativeinternal.FeatureProgrammer_IExplore{
+            Tracable: props.Config.Trace,
+            Source:   "function",
+            From:     "array",
+            Postfix:  "",
+          },
+        }),
+      ),
+    }))
+  }
+  return output
 }
 
 func notationGeneralProgrammer_write_tuple_functions(props struct {
-	Config     nativeinternal.FeatureProgrammer_IConfig
-	Rename     NotationGeneralProgrammer_IRename
-	Context    nativecontext.ITypiaContext
-	Functor    *nativehelpers.FunctionProgrammer
-	Collection *schemametadata.MetadataCollection
+  Config     nativeinternal.FeatureProgrammer_IConfig
+  Rename     NotationGeneralProgrammer_IRename
+  Context    nativecontext.ITypiaContext
+  Functor    *nativehelpers.FunctionProgrammer
+  Collection *schemametadata.MetadataCollection
 }) []*shimast.Node {
-	output := []*shimast.Node{}
-	for i, tuple := range props.Collection.Tuples() {
-		if tuple.Recursive == false {
-			continue
-		}
-		output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-			Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
-			Value: notationGeneralProgrammer_factory.NewArrowFunction(
-				nil,
-				nil,
-				notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
-					Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-					Type:   nativefactories.TypeFactory.Keyword("any"),
-					Input:  notationGeneralProgrammer_factory.NewIdentifier("input"),
-				})),
-				nativefactories.TypeFactory.Keyword("any"),
-				nil,
-				notationGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-				notationGeneralProgrammer_decode_tuple_inline(notationGeneralProgrammer_decodeTupleInlineProps{
-					Context: props.Context,
-					Rename:  props.Rename,
-					Config:  props.Config,
-					Functor: props.Functor,
-					Input:   notationGeneralProgrammer_factory.NewIdentifier("input"),
-					Tuple:   tuple,
-					Explore: nativeinternal.FeatureProgrammer_IExplore{
-						Tracable: props.Config.Trace,
-						Source:   "function",
-						From:     "array",
-						Postfix:  "",
-					},
-				}),
-			),
-		}))
-	}
-	return output
+  output := []*shimast.Node{}
+  for i, tuple := range props.Collection.Tuples() {
+    if tuple.Recursive == false {
+      continue
+    }
+    output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Value: notationGeneralProgrammer_factory.NewArrowFunction(
+        nil,
+        nil,
+        notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
+          Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+          Type:   nativefactories.TypeFactory.Keyword("any"),
+          Input:  notationGeneralProgrammer_factory.NewIdentifier("input"),
+        })),
+        nativefactories.TypeFactory.Keyword("any"),
+        nil,
+        notationGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+        notationGeneralProgrammer_decode_tuple_inline(notationGeneralProgrammer_decodeTupleInlineProps{
+          Context: props.Context,
+          Rename:  props.Rename,
+          Config:  props.Config,
+          Functor: props.Functor,
+          Input:   notationGeneralProgrammer_factory.NewIdentifier("input"),
+          Tuple:   tuple,
+          Explore: nativeinternal.FeatureProgrammer_IExplore{
+            Tracable: props.Config.Trace,
+            Source:   "function",
+            From:     "array",
+            Postfix:  "",
+          },
+        }),
+      ),
+    }))
+  }
+  return output
 }
 
 func notationGeneralProgrammer_decode(props struct {
-	Config   nativeinternal.FeatureProgrammer_IConfig
-	Rename   NotationGeneralProgrammer_IRename
-	Context  nativecontext.ITypiaContext
-	Functor  *nativehelpers.FunctionProgrammer
-	Metadata *schemametadata.MetadataSchema
-	Explore  nativeinternal.FeatureProgrammer_IExplore
-	Input    *shimast.Node
+  Config   nativeinternal.FeatureProgrammer_IConfig
+  Rename   NotationGeneralProgrammer_IRename
+  Context  nativecontext.ITypiaContext
+  Functor  *nativehelpers.FunctionProgrammer
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativeinternal.FeatureProgrammer_IExplore
+  Input    *shimast.Node
 }) *shimast.Node {
-	if props.Metadata.Any ||
-		notationGeneralProgrammer_some_arrays(props.Metadata.Arrays, func(a *schemametadata.MetadataArray) bool { return a.Type.Value.Any }) ||
-		notationGeneralProgrammer_some_tuples(props.Metadata.Tuples, func(t *schemametadata.MetadataTuple) bool {
-			return len(t.Type.Elements) != 0 && notationGeneralProgrammer_every_schema(t.Type.Elements, func(e *schemametadata.MetadataSchema) bool { return e.Any })
-		}) {
-		return nativefactories.ExpressionFactory.Currying(nativefactories.ExpressionFactory_CurryingProps{
-			Function: notationGeneralProgrammer_internal(props.Context, "notationAny"),
-			Arguments: []*shimast.Expression{
-				notationGeneralProgrammer_internal(props.Context, "notation"+notationGeneralProgrammer_capitalize(props.Rename.Name)),
-				props.Input,
-			},
-		})
-	}
-
-	unions := []notationGeneralProgrammer_IUnion{}
-	if len(props.Metadata.Functions) != 0 {
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "functional",
-			Is: func() *shimast.Node {
-				return notationGeneralProgrammer_binary(
-					notationGeneralProgrammer_factory.NewStringLiteral("function", shimast.TokenFlagsNone),
-					shimast.KindEqualsEqualsEqualsToken,
-					notationGeneralProgrammer_factory.NewTypeOfExpression(props.Input),
-				)
-			},
-			Value: func() *shimast.Node {
-				return notationGeneralProgrammer_factory.NewIdentifier("undefined")
-			},
-		})
-	}
-
-	for _, tuple := range props.Metadata.Tuples {
-		tuple := tuple
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "tuple",
-			Is: func() *shimast.Node {
-				partial := schemametadata.MetadataSchema_initialize()
-				partial.Tuples = append(partial.Tuples, tuple)
-				return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
-					Context:  props.Context,
-					Functor:  props.Functor,
-					Input:    props.Input,
-					Metadata: partial,
-					Explore:  notationGeneralProgrammer_checker_explore(props.Explore),
-				})
-			},
-			Value: func() *shimast.Node {
-				return notationGeneralProgrammer_decode_tuple(notationGeneralProgrammer_decodeTupleProps{
-					Config:  props.Config,
-					Rename:  props.Rename,
-					Context: props.Context,
-					Functor: props.Functor,
-					Tuple:   tuple,
-					Explore: props.Explore,
-					Input:   props.Input,
-				})
-			},
-		})
-	}
-
-	if len(props.Metadata.Arrays) != 0 {
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "array",
-			Is: func() *shimast.Node {
-				return nativefactories.ExpressionFactory.IsArray(props.Input)
-			},
-			Value: func() *shimast.Node {
-				explore := props.Explore
-				explore.From = "array"
-				return notationGeneralProgrammer_explore_arrays(notationGeneralProgrammer_exploreArraysProps{
-					Context: props.Context,
-					Config:  props.Config,
-					Functor: props.Functor,
-					Input:   props.Input,
-					Arrays:  props.Metadata.Arrays,
-					Explore: explore,
-				})
-			},
-		})
-	}
-
-	if len(props.Metadata.Sets) != 0 {
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "set",
-			Is: func() *shimast.Node {
-				return nativefactories.ExpressionFactory.IsInstanceOf("Set", props.Input)
-			},
-			Value: func() *shimast.Node {
-				explore := props.Explore
-				explore.From = "array"
-				return notationGeneralProgrammer_explore_sets(notationGeneralProgrammer_exploreSetsProps{
-					Context: props.Context,
-					Config:  props.Config,
-					Functor: props.Functor,
-					Input:   props.Input,
-					Explore: explore,
-					Sets:    props.Metadata.Sets,
-				})
-			},
-		})
-	}
-
-	if len(props.Metadata.Maps) != 0 {
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "map",
-			Is: func() *shimast.Node {
-				return nativefactories.ExpressionFactory.IsInstanceOf("Map", props.Input)
-			},
-			Value: func() *shimast.Node {
-				explore := props.Explore
-				explore.From = "array"
-				return notationGeneralProgrammer_explore_maps(notationGeneralProgrammer_exploreMapsProps{
-					Context: props.Context,
-					Config:  props.Config,
-					Functor: props.Functor,
-					Input:   props.Input,
-					Maps:    props.Metadata.Maps,
-					Explore: explore,
-				})
-			},
-		})
-	}
-
-	for _, native := range props.Metadata.Natives {
-		native := native
-		if native.Name == "WeakSet" || native.Name == "WeakMap" {
-			continue
-		}
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "native",
-			Is: func() *shimast.Node {
-				return nativefactories.ExpressionFactory.IsInstanceOf(native.Name, props.Input)
-			},
-			Value: func() *shimast.Node {
-				if native.Name == "Boolean" || native.Name == "Number" || native.Name == "String" {
-					return notationGeneralProgrammer_factory.NewCallExpression(
-						nativefactories.IdentifierFactory.Access(props.Input, "valueOf"),
-						nil,
-						nil,
-						nil,
-						shimast.NodeFlagsNone,
-					)
-				}
-				return notationGeneralProgrammer_decode_native(struct {
-					Name  string
-					Input *shimast.Node
-				}{Name: native.Name, Input: props.Input})
-			},
-		})
-	}
-
-	if len(props.Metadata.Objects) != 0 {
-		unions = append(unions, notationGeneralProgrammer_IUnion{
-			Type: "object",
-			Is: func() *shimast.Node {
-				return nativefactories.ExpressionFactory.IsObject(nativefactories.ExpressionFactory_IsObjectProps{
-					CheckNull:  true,
-					CheckArray: false,
-					Input:      props.Input,
-				})
-			},
-			Value: func() *shimast.Node {
-				explore := props.Explore
-				explore.From = "object"
-				return notationGeneralProgrammer_explore_objects(notationGeneralProgrammer_exploreObjectsProps{
-					Config:   props.Config,
-					Functor:  props.Functor,
-					Input:    props.Input,
-					Metadata: props.Metadata,
-					Explore:  explore,
-				})
-			},
-		})
-	}
-
-	if len(unions) == 0 {
-		return props.Input
-	}
-	if len(unions) == 1 && props.Metadata.Size() == 1 {
-		value := unions[0].Value()
-		if (props.Metadata.Nullable || props.Metadata.IsRequired() == false) && notationGeneralProgrammer_is_instance(props.Metadata) {
-			value = notationGeneralProgrammer_factory.NewConditionalExpression(
-				props.Input,
-				nil,
-				value,
-				nil,
-				props.Input,
-			)
-		}
-		return notationGeneralProgrammer_factory.NewAsExpression(value, nativefactories.TypeFactory.Keyword("any"))
-	}
-	last := props.Input
-	for i := len(unions) - 1; i >= 0; i-- {
-		union := unions[i]
-		last = notationGeneralProgrammer_factory.NewConditionalExpression(
-			union.Is(),
-			nil,
-			union.Value(),
-			nil,
-			last,
-		)
-	}
-	return notationGeneralProgrammer_factory.NewAsExpression(last, nativefactories.TypeFactory.Keyword("any"))
+  if props.Metadata.Any ||
+    notationGeneralProgrammer_some_arrays(props.Metadata.Arrays, func(a *schemametadata.MetadataArray) bool { return a.Type.Value.Any }) ||
+    notationGeneralProgrammer_some_tuples(props.Metadata.Tuples, func(t *schemametadata.MetadataTuple) bool {
+      return len(t.Type.Elements) != 0 && notationGeneralProgrammer_every_schema(t.Type.Elements, func(e *schemametadata.MetadataSchema) bool { return e.Any })
+    }) {
+    return nativefactories.ExpressionFactory.Currying(nativefactories.ExpressionFactory_CurryingProps{
+      Function: notationGeneralProgrammer_internal(props.Context, "notationAny"),
+      Arguments: []*shimast.Expression{
+        notationGeneralProgrammer_internal(props.Context, "notation"+notationGeneralProgrammer_capitalize(props.Rename.Name)),
+        props.Input,
+      },
+    })
+  }
+
+  unions := []notationGeneralProgrammer_IUnion{}
+  if len(props.Metadata.Functions) != 0 {
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "functional",
+      Is: func() *shimast.Node {
+        return notationGeneralProgrammer_binary(
+          notationGeneralProgrammer_factory.NewStringLiteral("function", shimast.TokenFlagsNone),
+          shimast.KindEqualsEqualsEqualsToken,
+          notationGeneralProgrammer_factory.NewTypeOfExpression(props.Input),
+        )
+      },
+      Value: func() *shimast.Node {
+        return notationGeneralProgrammer_factory.NewIdentifier("undefined")
+      },
+    })
+  }
+
+  for _, tuple := range props.Metadata.Tuples {
+    tuple := tuple
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "tuple",
+      Is: func() *shimast.Node {
+        partial := schemametadata.MetadataSchema_initialize()
+        partial.Tuples = append(partial.Tuples, tuple)
+        return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
+          Context:  props.Context,
+          Functor:  props.Functor,
+          Input:    props.Input,
+          Metadata: partial,
+          Explore:  notationGeneralProgrammer_checker_explore(props.Explore),
+        })
+      },
+      Value: func() *shimast.Node {
+        return notationGeneralProgrammer_decode_tuple(notationGeneralProgrammer_decodeTupleProps{
+          Config:  props.Config,
+          Rename:  props.Rename,
+          Context: props.Context,
+          Functor: props.Functor,
+          Tuple:   tuple,
+          Explore: props.Explore,
+          Input:   props.Input,
+        })
+      },
+    })
+  }
+
+  if len(props.Metadata.Arrays) != 0 {
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "array",
+      Is: func() *shimast.Node {
+        return nativefactories.ExpressionFactory.IsArray(props.Input)
+      },
+      Value: func() *shimast.Node {
+        explore := props.Explore
+        explore.From = "array"
+        return notationGeneralProgrammer_explore_arrays(notationGeneralProgrammer_exploreArraysProps{
+          Context: props.Context,
+          Config:  props.Config,
+          Functor: props.Functor,
+          Input:   props.Input,
+          Arrays:  props.Metadata.Arrays,
+          Explore: explore,
+        })
+      },
+    })
+  }
+
+  if len(props.Metadata.Sets) != 0 {
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "set",
+      Is: func() *shimast.Node {
+        return nativefactories.ExpressionFactory.IsInstanceOf("Set", props.Input)
+      },
+      Value: func() *shimast.Node {
+        explore := props.Explore
+        explore.From = "array"
+        return notationGeneralProgrammer_explore_sets(notationGeneralProgrammer_exploreSetsProps{
+          Context: props.Context,
+          Config:  props.Config,
+          Functor: props.Functor,
+          Input:   props.Input,
+          Explore: explore,
+          Sets:    props.Metadata.Sets,
+        })
+      },
+    })
+  }
+
+  if len(props.Metadata.Maps) != 0 {
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "map",
+      Is: func() *shimast.Node {
+        return nativefactories.ExpressionFactory.IsInstanceOf("Map", props.Input)
+      },
+      Value: func() *shimast.Node {
+        explore := props.Explore
+        explore.From = "array"
+        return notationGeneralProgrammer_explore_maps(notationGeneralProgrammer_exploreMapsProps{
+          Context: props.Context,
+          Config:  props.Config,
+          Functor: props.Functor,
+          Input:   props.Input,
+          Maps:    props.Metadata.Maps,
+          Explore: explore,
+        })
+      },
+    })
+  }
+
+  for _, native := range props.Metadata.Natives {
+    native := native
+    if native.Name == "WeakSet" || native.Name == "WeakMap" {
+      continue
+    }
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "native",
+      Is: func() *shimast.Node {
+        return nativefactories.ExpressionFactory.IsInstanceOf(native.Name, props.Input)
+      },
+      Value: func() *shimast.Node {
+        if native.Name == "Boolean" || native.Name == "Number" || native.Name == "String" {
+          return notationGeneralProgrammer_factory.NewCallExpression(
+            nativefactories.IdentifierFactory.Access(props.Input, "valueOf"),
+            nil,
+            nil,
+            nil,
+            shimast.NodeFlagsNone,
+          )
+        }
+        return notationGeneralProgrammer_decode_native(struct {
+          Name  string
+          Input *shimast.Node
+        }{Name: native.Name, Input: props.Input})
+      },
+    })
+  }
+
+  if len(props.Metadata.Objects) != 0 {
+    unions = append(unions, notationGeneralProgrammer_IUnion{
+      Type: "object",
+      Is: func() *shimast.Node {
+        return nativefactories.ExpressionFactory.IsObject(nativefactories.ExpressionFactory_IsObjectProps{
+          CheckNull:  true,
+          CheckArray: false,
+          Input:      props.Input,
+        })
+      },
+      Value: func() *shimast.Node {
+        explore := props.Explore
+        explore.From = "object"
+        return notationGeneralProgrammer_explore_objects(notationGeneralProgrammer_exploreObjectsProps{
+          Config:   props.Config,
+          Functor:  props.Functor,
+          Input:    props.Input,
+          Metadata: props.Metadata,
+          Explore:  explore,
+        })
+      },
+    })
+  }
+
+  if len(unions) == 0 {
+    return props.Input
+  }
+  if len(unions) == 1 && props.Metadata.Size() == 1 {
+    value := unions[0].Value()
+    if (props.Metadata.Nullable || props.Metadata.IsRequired() == false) && notationGeneralProgrammer_is_instance(props.Metadata) {
+      value = notationGeneralProgrammer_factory.NewConditionalExpression(
+        props.Input,
+        nil,
+        value,
+        nil,
+        props.Input,
+      )
+    }
+    return notationGeneralProgrammer_factory.NewAsExpression(value, nativefactories.TypeFactory.Keyword("any"))
+  }
+  last := props.Input
+  for i := len(unions) - 1; i >= 0; i-- {
+    union := unions[i]
+    last = notationGeneralProgrammer_factory.NewConditionalExpression(
+      union.Is(),
+      nil,
+      union.Value(),
+      nil,
+      last,
+    )
+  }
+  return notationGeneralProgrammer_factory.NewAsExpression(last, nativefactories.TypeFactory.Keyword("any"))
 }
 
 func notationGeneralProgrammer_decode_object(props struct {
-	Functor *nativehelpers.FunctionProgrammer
-	Object  *schemametadata.MetadataObjectType
-	Input   *shimast.Node
-	Explore nativeinternal.FeatureProgrammer_IExplore
+  Functor *nativehelpers.FunctionProgrammer
+  Object  *schemametadata.MetadataObjectType
+  Input   *shimast.Node
+  Explore nativeinternal.FeatureProgrammer_IExplore
 }) *shimast.Node {
-	return nativeinternal.FeatureProgrammer.Decode_object(nativeinternal.FeatureProgrammer_DecodeObjectProps{
-		Config:  nativeinternal.FeatureProgrammer_DecodeObjectConfig{Trace: false, Path: false, Prefix: notationGeneralProgrammer_PREFIX},
-		Functor: props.Functor,
-		Object:  props.Object,
-		Input:   props.Input,
-		Explore: props.Explore,
-	})
+  return nativeinternal.FeatureProgrammer.Decode_object(nativeinternal.FeatureProgrammer_DecodeObjectProps{
+    Config:  nativeinternal.FeatureProgrammer_DecodeObjectConfig{Trace: false, Path: false, Prefix: notationGeneralProgrammer_PREFIX},
+    Functor: props.Functor,
+    Object:  props.Object,
+    Input:   props.Input,
+    Explore: props.Explore,
+  })
 }
 
 type notationGeneralProgrammer_decodeArrayProps struct {
-	Config  nativeinternal.FeatureProgrammer_IConfig
-	Functor *nativehelpers.FunctionProgrammer
-	Input   *shimast.Node
-	Array   *schemametadata.MetadataArray
-	Explore nativeinternal.FeatureProgrammer_IExplore
+  Config  nativeinternal.FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Input   *shimast.Node
+  Array   *schemametadata.MetadataArray
+  Explore nativeinternal.FeatureProgrammer_IExplore
 }
 
 func notationGeneralProgrammer_decode_array(props notationGeneralProgrammer_decodeArrayProps) *shimast.Node {
-	if props.Array.Type.Recursive {
-		index := 0
-		if props.Array.Type.Index != nil {
-			index = *props.Array.Type.Index
-		}
-		return notationGeneralProgrammer_factory.NewCallExpression(
-			notationGeneralProgrammer_factory.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%sa%d", props.Config.Prefix, index))),
-			nil,
-			nil,
-			notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
-				Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-				Explore: notationGeneralProgrammer_explore_with(props.Explore, "function", "array"),
-				Input:   props.Input,
-			})),
-			shimast.NodeFlagsNone,
-		)
-	}
-	return notationGeneralProgrammer_decode_array_inline(props)
+  if props.Array.Type.Recursive {
+    index := 0
+    if props.Array.Type.Index != nil {
+      index = *props.Array.Type.Index
+    }
+    return notationGeneralProgrammer_factory.NewCallExpression(
+      notationGeneralProgrammer_factory.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%sa%d", props.Config.Prefix, index))),
+      nil,
+      nil,
+      notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+        Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+        Explore: notationGeneralProgrammer_explore_with(props.Explore, "function", "array"),
+        Input:   props.Input,
+      })),
+      shimast.NodeFlagsNone,
+    )
+  }
+  return notationGeneralProgrammer_decode_array_inline(props)
 }
 
 func notationGeneralProgrammer_decode_array_inline(props notationGeneralProgrammer_decodeArrayProps) *shimast.Node {
-	return nativeinternal.FeatureProgrammer.Decode_array(nativeinternal.FeatureProgrammer_DecodeArrayProps{
-		Config: nativeinternal.FeatureProgrammer_DecodeArrayConfig{
-			Trace:   props.Config.Trace,
-			Path:    props.Config.Path,
-			Prefix:  props.Config.Prefix,
-			Decoder: props.Config.Decoder,
-		},
-		Functor: props.Functor,
-		Combiner: func(next struct {
-			Input *shimast.Expression
-			Arrow *shimast.Node
-		}) *shimast.Node {
-			return nativehelpers.NotationJoiner.Array(nativehelpers.NotationJoiner_ArrayProps{
-				Input: next.Input,
-				Arrow: next.Arrow,
-			})
-		},
-		Array:   props.Array,
-		Input:   props.Input,
-		Explore: props.Explore,
-	})
+  return nativeinternal.FeatureProgrammer.Decode_array(nativeinternal.FeatureProgrammer_DecodeArrayProps{
+    Config: nativeinternal.FeatureProgrammer_DecodeArrayConfig{
+      Trace:   props.Config.Trace,
+      Path:    props.Config.Path,
+      Prefix:  props.Config.Prefix,
+      Decoder: props.Config.Decoder,
+    },
+    Functor: props.Functor,
+    Combiner: func(next struct {
+      Input *shimast.Expression
+      Arrow *shimast.Node
+    }) *shimast.Node {
+      return nativehelpers.NotationJoiner.Array(nativehelpers.NotationJoiner_ArrayProps{
+        Input: next.Input,
+        Arrow: next.Arrow,
+      })
+    },
+    Array:   props.Array,
+    Input:   props.Input,
+    Explore: props.Explore,
+  })
 }
 
 type notationGeneralProgrammer_decodeTupleProps struct {
-	Config  nativeinternal.FeatureProgrammer_IConfig
-	Rename  NotationGeneralProgrammer_IRename
-	Context nativecontext.ITypiaContext
-	Functor *nativehelpers.FunctionProgrammer
-	Tuple   *schemametadata.MetadataTuple
-	Explore nativeinternal.FeatureProgrammer_IExplore
-	Input   *shimast.Node
+  Config  nativeinternal.FeatureProgrammer_IConfig
+  Rename  NotationGeneralProgrammer_IRename
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Tuple   *schemametadata.MetadataTuple
+  Explore nativeinternal.FeatureProgrammer_IExplore
+  Input   *shimast.Node
 }
 
 func notationGeneralProgrammer_decode_tuple(props notationGeneralProgrammer_decodeTupleProps) *shimast.Node {
-	if props.Tuple.Type.Recursive {
-		index := 0
-		if props.Tuple.Type.Index != nil {
-			index = *props.Tuple.Type.Index
-		}
-		return notationGeneralProgrammer_factory.NewCallExpression(
-			notationGeneralProgrammer_factory.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%st%d", props.Config.Prefix, index))),
-			nil,
-			nil,
-			notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
-				Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-				Explore: notationGeneralProgrammer_explore_with(props.Explore, "function", props.Explore.From),
-				Input:   props.Input,
-			})),
-			shimast.NodeFlagsNone,
-		)
-	}
-	return notationGeneralProgrammer_decode_tuple_inline(notationGeneralProgrammer_decodeTupleInlineProps{
-		Context: props.Context,
-		Rename:  props.Rename,
-		Config:  props.Config,
-		Functor: props.Functor,
-		Tuple:   props.Tuple.Type,
-		Explore: props.Explore,
-		Input:   props.Input,
-	})
+  if props.Tuple.Type.Recursive {
+    index := 0
+    if props.Tuple.Type.Index != nil {
+      index = *props.Tuple.Type.Index
+    }
+    return notationGeneralProgrammer_factory.NewCallExpression(
+      notationGeneralProgrammer_factory.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%st%d", props.Config.Prefix, index))),
+      nil,
+      nil,
+      notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+        Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+        Explore: notationGeneralProgrammer_explore_with(props.Explore, "function", props.Explore.From),
+        Input:   props.Input,
+      })),
+      shimast.NodeFlagsNone,
+    )
+  }
+  return notationGeneralProgrammer_decode_tuple_inline(notationGeneralProgrammer_decodeTupleInlineProps{
+    Context: props.Context,
+    Rename:  props.Rename,
+    Config:  props.Config,
+    Functor: props.Functor,
+    Tuple:   props.Tuple.Type,
+    Explore: props.Explore,
+    Input:   props.Input,
+  })
 }
 
 type notationGeneralProgrammer_decodeTupleInlineProps struct {
-	Context nativecontext.ITypiaContext
-	Rename  NotationGeneralProgrammer_IRename
-	Config  nativeinternal.FeatureProgrammer_IConfig
-	Functor *nativehelpers.FunctionProgrammer
-	Explore nativeinternal.FeatureProgrammer_IExplore
-	Tuple   *schemametadata.MetadataTupleType
-	Input   *shimast.Node
+  Context nativecontext.ITypiaContext
+  Rename  NotationGeneralProgrammer_IRename
+  Config  nativeinternal.FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Explore nativeinternal.FeatureProgrammer_IExplore
+  Tuple   *schemametadata.MetadataTupleType
+  Input   *shimast.Node
 }
 
 func notationGeneralProgrammer_decode_tuple_inline(props notationGeneralProgrammer_decodeTupleInlineProps) *shimast.Node {
-	elements := []*shimast.Node{}
-	for index, elem := range props.Tuple.Elements {
-		if elem.Rest != nil {
-			continue
-		}
-		explore := props.Explore
-		explore.From = "array"
-		if len(props.Explore.Postfix) != 0 {
-			explore.Postfix = fmt.Sprintf("%s[%d]\"", nativeiterate.Postfix_of_tuple_export(props.Explore.Postfix), index)
-		} else {
-			explore.Postfix = fmt.Sprintf("\"[%d]\"", index)
-		}
-		elements = append(elements, notationGeneralProgrammer_decode(struct {
-			Config   nativeinternal.FeatureProgrammer_IConfig
-			Rename   NotationGeneralProgrammer_IRename
-			Context  nativecontext.ITypiaContext
-			Functor  *nativehelpers.FunctionProgrammer
-			Metadata *schemametadata.MetadataSchema
-			Explore  nativeinternal.FeatureProgrammer_IExplore
-			Input    *shimast.Node
-		}{
-			Config:   props.Config,
-			Rename:   props.Rename,
-			Context:  props.Context,
-			Functor:  props.Functor,
-			Metadata: elem,
-			Explore:  explore,
-			Input:    notationGeneralProgrammer_factory.NewElementAccessExpression(props.Input, nil, nativefactories.ExpressionFactory.Number(index), shimast.NodeFlagsNone),
-		}))
-	}
-	var rest *shimast.Node
-	if len(props.Tuple.Elements) != 0 {
-		last := props.Tuple.Elements[len(props.Tuple.Elements)-1]
-		if last.Rest != nil {
-			start := len(props.Tuple.Elements) - 1
-			explore := props.Explore
-			explore.Start = &start
-			rest = notationGeneralProgrammer_decode(struct {
-				Config   nativeinternal.FeatureProgrammer_IConfig
-				Rename   NotationGeneralProgrammer_IRename
-				Context  nativecontext.ITypiaContext
-				Functor  *nativehelpers.FunctionProgrammer
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativeinternal.FeatureProgrammer_IExplore
-				Input    *shimast.Node
-			}{
-				Config:  props.Config,
-				Rename:  props.Rename,
-				Context: props.Context,
-				Functor: props.Functor,
-				Input: notationGeneralProgrammer_factory.NewCallExpression(
-					nativefactories.IdentifierFactory.Access(props.Input, "slice"),
-					nil,
-					nil,
-					notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{nativefactories.ExpressionFactory.Number(start)}),
-					shimast.NodeFlagsNone,
-				),
-				Metadata: nativeiterate.Wrap_metadata_rest_tuple_export(last.Rest),
-				Explore:  explore,
-			})
-		}
-	}
-	return nativehelpers.NotationJoiner.Tuple(nativehelpers.NotationJoiner_TupleProps{
-		Elements: elements,
-		Rest:     rest,
-	})
+  elements := []*shimast.Node{}
+  for index, elem := range props.Tuple.Elements {
+    if elem.Rest != nil {
+      continue
+    }
+    explore := props.Explore
+    explore.From = "array"
+    if len(props.Explore.Postfix) != 0 {
+      explore.Postfix = fmt.Sprintf("%s[%d]\"", nativeiterate.Postfix_of_tuple_export(props.Explore.Postfix), index)
+    } else {
+      explore.Postfix = fmt.Sprintf("\"[%d]\"", index)
+    }
+    elements = append(elements, notationGeneralProgrammer_decode(struct {
+      Config   nativeinternal.FeatureProgrammer_IConfig
+      Rename   NotationGeneralProgrammer_IRename
+      Context  nativecontext.ITypiaContext
+      Functor  *nativehelpers.FunctionProgrammer
+      Metadata *schemametadata.MetadataSchema
+      Explore  nativeinternal.FeatureProgrammer_IExplore
+      Input    *shimast.Node
+    }{
+      Config:   props.Config,
+      Rename:   props.Rename,
+      Context:  props.Context,
+      Functor:  props.Functor,
+      Metadata: elem,
+      Explore:  explore,
+      Input:    notationGeneralProgrammer_factory.NewElementAccessExpression(props.Input, nil, nativefactories.ExpressionFactory.Number(index), shimast.NodeFlagsNone),
+    }))
+  }
+  var rest *shimast.Node
+  if len(props.Tuple.Elements) != 0 {
+    last := props.Tuple.Elements[len(props.Tuple.Elements)-1]
+    if last.Rest != nil {
+      start := len(props.Tuple.Elements) - 1
+      explore := props.Explore
+      explore.Start = &start
+      rest = notationGeneralProgrammer_decode(struct {
+        Config   nativeinternal.FeatureProgrammer_IConfig
+        Rename   NotationGeneralProgrammer_IRename
+        Context  nativecontext.ITypiaContext
+        Functor  *nativehelpers.FunctionProgrammer
+        Metadata *schemametadata.MetadataSchema
+        Explore  nativeinternal.FeatureProgrammer_IExplore
+        Input    *shimast.Node
+      }{
+        Config:  props.Config,
+        Rename:  props.Rename,
+        Context: props.Context,
+        Functor: props.Functor,
+        Input: notationGeneralProgrammer_factory.NewCallExpression(
+          nativefactories.IdentifierFactory.Access(props.Input, "slice"),
+          nil,
+          nil,
+          notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{nativefactories.ExpressionFactory.Number(start)}),
+          shimast.NodeFlagsNone,
+        ),
+        Metadata: nativeiterate.Wrap_metadata_rest_tuple_export(last.Rest),
+        Explore:  explore,
+      })
+    }
+  }
+  return nativehelpers.NotationJoiner.Tuple(nativehelpers.NotationJoiner_TupleProps{
+    Elements: elements,
+    Rest:     rest,
+  })
 }
 
 func notationGeneralProgrammer_decode_native(props struct {
-	Name  string
-	Input *shimast.Node
+  Name  string
+  Input *shimast.Node
 }) *shimast.Node {
-	if props.Name == "Date" {
-		return notationGeneralProgrammer_factory.NewNewExpression(
-			notationGeneralProgrammer_factory.NewIdentifier(props.Name),
-			nil,
-			notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{props.Input}),
-		)
-	}
-	return props.Input
+  if props.Name == "Date" {
+    return notationGeneralProgrammer_factory.NewNewExpression(
+      notationGeneralProgrammer_factory.NewIdentifier(props.Name),
+      nil,
+      notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{props.Input}),
+    )
+  }
+  return props.Input
 }
 
 type notationGeneralProgrammer_exploreSetsProps struct {
-	Context nativecontext.ITypiaContext
-	Config  nativeinternal.FeatureProgrammer_IConfig
-	Functor *nativehelpers.FunctionProgrammer
-	Input   *shimast.Node
-	Explore nativeinternal.FeatureProgrammer_IExplore
-	Sets    []*schemametadata.MetadataSet
+  Context nativecontext.ITypiaContext
+  Config  nativeinternal.FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Input   *shimast.Node
+  Explore nativeinternal.FeatureProgrammer_IExplore
+  Sets    []*schemametadata.MetadataSet
 }
 
 func notationGeneralProgrammer_explore_sets(props notationGeneralProgrammer_exploreSetsProps) *shimast.Node {
-	return notationGeneralProgrammer_factory.NewCallExpression(
-		nativehelpers.UnionExplorer.Set(nativehelpers.UnionExplorer_SetProps{
-			Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
-				Checker: func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-					return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
-						Context:  props.Context,
-						Functor:  props.Functor,
-						Input:    v.Input,
-						Metadata: v.Definition.(*schemametadata.MetadataSchema),
-						Explore:  notationGeneralProgrammer_checker_explore(v.Explore),
-					})
-				},
-				Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-					return notationGeneralProgrammer_factory.NewNewExpression(
-						notationGeneralProgrammer_factory.NewIdentifier("Set"),
-						notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{nativefactories.TypeFactory.Keyword("any")}),
-						notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-							notationGeneralProgrammer_decode_array(notationGeneralProgrammer_decodeArrayProps{
-								Config:  props.Config,
-								Functor: props.Functor,
-								Input:   v.Input,
-								Array:   v.Definition.(*schemametadata.MetadataArray),
-								Explore: notationGeneralProgrammer_feature_explore(v.Explore),
-							}),
-						}),
-					)
-				},
-				Empty: notationGeneralProgrammer_factory.NewNewExpression(
-					notationGeneralProgrammer_factory.NewIdentifier("Set"),
-					notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{nativefactories.TypeFactory.Keyword("any")}),
-					nil,
-				),
-				Success: notationGeneralProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
-				Failure: func(v nativehelpers.UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
-					return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
-						Context:  props.Context,
-						Functor:  props.Functor,
-						Expected: v.Expected,
-						Input:    v.Input,
-					})
-				},
-			},
-			Parameters: nil,
-			Input:      props.Input,
-			Sets:       props.Sets,
-			Explore:    props.Explore,
-		}),
-		nil,
-		nil,
-		nil,
-		shimast.NodeFlagsNone,
-	)
+  return notationGeneralProgrammer_factory.NewCallExpression(
+    nativehelpers.UnionExplorer.Set(nativehelpers.UnionExplorer_SetProps{
+      Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
+        Checker: func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+          return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
+            Context:  props.Context,
+            Functor:  props.Functor,
+            Input:    v.Input,
+            Metadata: v.Definition.(*schemametadata.MetadataSchema),
+            Explore:  notationGeneralProgrammer_checker_explore(v.Explore),
+          })
+        },
+        Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+          return notationGeneralProgrammer_factory.NewNewExpression(
+            notationGeneralProgrammer_factory.NewIdentifier("Set"),
+            notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{nativefactories.TypeFactory.Keyword("any")}),
+            notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+              notationGeneralProgrammer_decode_array(notationGeneralProgrammer_decodeArrayProps{
+                Config:  props.Config,
+                Functor: props.Functor,
+                Input:   v.Input,
+                Array:   v.Definition.(*schemametadata.MetadataArray),
+                Explore: notationGeneralProgrammer_feature_explore(v.Explore),
+              }),
+            }),
+          )
+        },
+        Empty: notationGeneralProgrammer_factory.NewNewExpression(
+          notationGeneralProgrammer_factory.NewIdentifier("Set"),
+          notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{nativefactories.TypeFactory.Keyword("any")}),
+          nil,
+        ),
+        Success: notationGeneralProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+        Failure: func(v nativehelpers.UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
+          return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
+            Context:  props.Context,
+            Functor:  props.Functor,
+            Expected: v.Expected,
+            Input:    v.Input,
+          })
+        },
+      },
+      Parameters: nil,
+      Input:      props.Input,
+      Sets:       props.Sets,
+      Explore:    props.Explore,
+    }),
+    nil,
+    nil,
+    nil,
+    shimast.NodeFlagsNone,
+  )
 }
 
 type notationGeneralProgrammer_exploreMapsProps struct {
-	Context nativecontext.ITypiaContext
-	Config  nativeinternal.FeatureProgrammer_IConfig
-	Functor *nativehelpers.FunctionProgrammer
-	Input   *shimast.Node
-	Maps    []*schemametadata.MetadataMap
-	Explore nativeinternal.FeatureProgrammer_IExplore
+  Context nativecontext.ITypiaContext
+  Config  nativeinternal.FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Input   *shimast.Node
+  Maps    []*schemametadata.MetadataMap
+  Explore nativeinternal.FeatureProgrammer_IExplore
 }
 
 func notationGeneralProgrammer_explore_maps(props notationGeneralProgrammer_exploreMapsProps) *shimast.Node {
-	return notationGeneralProgrammer_factory.NewCallExpression(
-		nativehelpers.UnionExplorer.Map(nativehelpers.UnionExplorer_MapProps{
-			Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
-				Checker: func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-					pair := v.Definition.([]*schemametadata.MetadataSchema)
-					first := nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
-						Context:  props.Context,
-						Functor:  props.Functor,
-						Input:    notationGeneralProgrammer_factory.NewElementAccessExpression(v.Input, nil, nativefactories.ExpressionFactory.Number(0), shimast.NodeFlagsNone),
-						Metadata: pair[0],
-						Explore:  notationGeneralProgrammer_checker_explore_with_postfix(v.Explore, "[0]"),
-					})
-					second := nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
-						Context:  props.Context,
-						Functor:  props.Functor,
-						Input:    notationGeneralProgrammer_factory.NewElementAccessExpression(v.Input, nil, nativefactories.ExpressionFactory.Number(1), shimast.NodeFlagsNone),
-						Metadata: pair[1],
-						Explore:  notationGeneralProgrammer_checker_explore_with_postfix(v.Explore, "[1]"),
-					})
-					return notationGeneralProgrammer_binary(first, shimast.KindAmpersandAmpersandToken, second)
-				},
-				Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-					return notationGeneralProgrammer_factory.NewNewExpression(
-						notationGeneralProgrammer_factory.NewIdentifier("Map"),
-						notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-							nativefactories.TypeFactory.Keyword("any"),
-							nativefactories.TypeFactory.Keyword("any"),
-						}),
-						notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-							notationGeneralProgrammer_decode_array(notationGeneralProgrammer_decodeArrayProps{
-								Config:  props.Config,
-								Functor: props.Functor,
-								Input:   v.Input,
-								Array:   v.Definition.(*schemametadata.MetadataArray),
-								Explore: notationGeneralProgrammer_feature_explore(v.Explore),
-							}),
-						}),
-					)
-				},
-				Empty: notationGeneralProgrammer_factory.NewNewExpression(
-					notationGeneralProgrammer_factory.NewIdentifier("Map"),
-					notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-						nativefactories.TypeFactory.Keyword("any"),
-						nativefactories.TypeFactory.Keyword("any"),
-					}),
-					nil,
-				),
-				Success: notationGeneralProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
-				Failure: func(v nativehelpers.UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
-					return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
-						Context:  props.Context,
-						Functor:  props.Functor,
-						Expected: v.Expected,
-						Input:    v.Input,
-					})
-				},
-			},
-			Parameters: nil,
-			Input:      props.Input,
-			Maps:       props.Maps,
-			Explore:    props.Explore,
-		}),
-		nil,
-		nil,
-		nil,
-		shimast.NodeFlagsNone,
-	)
+  return notationGeneralProgrammer_factory.NewCallExpression(
+    nativehelpers.UnionExplorer.Map(nativehelpers.UnionExplorer_MapProps{
+      Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
+        Checker: func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+          pair := v.Definition.([]*schemametadata.MetadataSchema)
+          first := nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
+            Context:  props.Context,
+            Functor:  props.Functor,
+            Input:    notationGeneralProgrammer_factory.NewElementAccessExpression(v.Input, nil, nativefactories.ExpressionFactory.Number(0), shimast.NodeFlagsNone),
+            Metadata: pair[0],
+            Explore:  notationGeneralProgrammer_checker_explore_with_postfix(v.Explore, "[0]"),
+          })
+          second := nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
+            Context:  props.Context,
+            Functor:  props.Functor,
+            Input:    notationGeneralProgrammer_factory.NewElementAccessExpression(v.Input, nil, nativefactories.ExpressionFactory.Number(1), shimast.NodeFlagsNone),
+            Metadata: pair[1],
+            Explore:  notationGeneralProgrammer_checker_explore_with_postfix(v.Explore, "[1]"),
+          })
+          return notationGeneralProgrammer_binary(first, shimast.KindAmpersandAmpersandToken, second)
+        },
+        Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+          return notationGeneralProgrammer_factory.NewNewExpression(
+            notationGeneralProgrammer_factory.NewIdentifier("Map"),
+            notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+              nativefactories.TypeFactory.Keyword("any"),
+              nativefactories.TypeFactory.Keyword("any"),
+            }),
+            notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+              notationGeneralProgrammer_decode_array(notationGeneralProgrammer_decodeArrayProps{
+                Config:  props.Config,
+                Functor: props.Functor,
+                Input:   v.Input,
+                Array:   v.Definition.(*schemametadata.MetadataArray),
+                Explore: notationGeneralProgrammer_feature_explore(v.Explore),
+              }),
+            }),
+          )
+        },
+        Empty: notationGeneralProgrammer_factory.NewNewExpression(
+          notationGeneralProgrammer_factory.NewIdentifier("Map"),
+          notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+            nativefactories.TypeFactory.Keyword("any"),
+            nativefactories.TypeFactory.Keyword("any"),
+          }),
+          nil,
+        ),
+        Success: notationGeneralProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+        Failure: func(v nativehelpers.UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
+          return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
+            Context:  props.Context,
+            Functor:  props.Functor,
+            Expected: v.Expected,
+            Input:    v.Input,
+          })
+        },
+      },
+      Parameters: nil,
+      Input:      props.Input,
+      Maps:       props.Maps,
+      Explore:    props.Explore,
+    }),
+    nil,
+    nil,
+    nil,
+    shimast.NodeFlagsNone,
+  )
 }
 
 type notationGeneralProgrammer_exploreObjectsProps struct {
-	Config   nativeinternal.FeatureProgrammer_IConfig
-	Functor  *nativehelpers.FunctionProgrammer
-	Input    *shimast.Node
-	Metadata *schemametadata.MetadataSchema
-	Explore  nativeinternal.FeatureProgrammer_IExplore
+  Config   nativeinternal.FeatureProgrammer_IConfig
+  Functor  *nativehelpers.FunctionProgrammer
+  Input    *shimast.Node
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativeinternal.FeatureProgrammer_IExplore
 }
 
 func notationGeneralProgrammer_explore_objects(props notationGeneralProgrammer_exploreObjectsProps) *shimast.Node {
-	if len(props.Metadata.Objects) == 1 {
-		return notationGeneralProgrammer_decode_object(struct {
-			Functor *nativehelpers.FunctionProgrammer
-			Object  *schemametadata.MetadataObjectType
-			Input   *shimast.Node
-			Explore nativeinternal.FeatureProgrammer_IExplore
-		}{Functor: props.Functor, Object: props.Metadata.Objects[0].Type, Input: props.Input, Explore: props.Explore})
-	}
-	index := 0
-	if props.Metadata.Union_index != nil {
-		index = *props.Metadata.Union_index
-	}
-	return notationGeneralProgrammer_factory.NewCallExpression(
-		notationGeneralProgrammer_factory.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%su%d", notationGeneralProgrammer_PREFIX, index))),
-		nil,
-		nil,
-		notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
-			Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-			Explore: props.Explore,
-			Input:   props.Input,
-		})),
-		shimast.NodeFlagsNone,
-	)
+  if len(props.Metadata.Objects) == 1 {
+    return notationGeneralProgrammer_decode_object(struct {
+      Functor *nativehelpers.FunctionProgrammer
+      Object  *schemametadata.MetadataObjectType
+      Input   *shimast.Node
+      Explore nativeinternal.FeatureProgrammer_IExplore
+    }{Functor: props.Functor, Object: props.Metadata.Objects[0].Type, Input: props.Input, Explore: props.Explore})
+  }
+  index := 0
+  if props.Metadata.Union_index != nil {
+    index = *props.Metadata.Union_index
+  }
+  return notationGeneralProgrammer_factory.NewCallExpression(
+    notationGeneralProgrammer_factory.NewIdentifier(props.Functor.UseLocal(fmt.Sprintf("%su%d", notationGeneralProgrammer_PREFIX, index))),
+    nil,
+    nil,
+    notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+      Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+      Explore: props.Explore,
+      Input:   props.Input,
+    })),
+    shimast.NodeFlagsNone,
+  )
 }
 
 type notationGeneralProgrammer_exploreArraysProps struct {
-	Context nativecontext.ITypiaContext
-	Config  nativeinternal.FeatureProgrammer_IConfig
-	Functor *nativehelpers.FunctionProgrammer
-	Input   *shimast.Node
-	Arrays  []*schemametadata.MetadataArray
-	Explore nativeinternal.FeatureProgrammer_IExplore
+  Context nativecontext.ITypiaContext
+  Config  nativeinternal.FeatureProgrammer_IConfig
+  Functor *nativehelpers.FunctionProgrammer
+  Input   *shimast.Node
+  Arrays  []*schemametadata.MetadataArray
+  Explore nativeinternal.FeatureProgrammer_IExplore
 }
 
 func notationGeneralProgrammer_explore_arrays(props notationGeneralProgrammer_exploreArraysProps) *shimast.Node {
-	return notationGeneralProgrammer_explore_array_like_union_types(notationGeneralProgrammer_exploreArrayLikeUnionTypesProps[*schemametadata.MetadataArray]{
-		Config:  props.Config,
-		Functor: props.Functor,
-		Factory: func(next notationGeneralProgrammer_arrayLikeFactoryProps[*schemametadata.MetadataArray]) *shimast.Node {
-			return nativehelpers.UnionExplorer.Array(nativehelpers.UnionExplorer_ArrayProps{
-				Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
-					Checker: func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-						return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
-							Context:  props.Context,
-							Functor:  props.Functor,
-							Input:    v.Input,
-							Metadata: v.Definition.(*schemametadata.MetadataSchema),
-							Explore:  notationGeneralProgrammer_checker_explore(v.Explore),
-						})
-					},
-					Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-						return notationGeneralProgrammer_decode_array(notationGeneralProgrammer_decodeArrayProps{
-							Config:  props.Config,
-							Functor: props.Functor,
-							Input:   v.Input,
-							Array:   v.Definition.(*schemametadata.MetadataArray),
-							Explore: notationGeneralProgrammer_feature_explore(v.Explore),
-						})
-					},
-					Empty:   notationGeneralProgrammer_factory.NewIdentifier("[]"),
-					Success: notationGeneralProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
-					Failure: func(v nativehelpers.UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
-						return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
-							Context:  props.Context,
-							Functor:  props.Functor,
-							Expected: v.Expected,
-							Input:    v.Input,
-						})
-					},
-				},
-				Parameters: next.Parameters,
-				Input:      next.Input,
-				Arrays:     next.Definitions,
-				Explore:    next.Explore,
-			})
-		},
-		Definitions: props.Arrays,
-		Input:       props.Input,
-		Explore:     props.Explore,
-	})
+  return notationGeneralProgrammer_explore_array_like_union_types(notationGeneralProgrammer_exploreArrayLikeUnionTypesProps[*schemametadata.MetadataArray]{
+    Config:  props.Config,
+    Functor: props.Functor,
+    Factory: func(next notationGeneralProgrammer_arrayLikeFactoryProps[*schemametadata.MetadataArray]) *shimast.Node {
+      return nativehelpers.UnionExplorer.Array(nativehelpers.UnionExplorer_ArrayProps{
+        Config: nativehelpers.UnionExplorer_ArrayLikeConfig{
+          Checker: func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+            return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
+              Context:  props.Context,
+              Functor:  props.Functor,
+              Input:    v.Input,
+              Metadata: v.Definition.(*schemametadata.MetadataSchema),
+              Explore:  notationGeneralProgrammer_checker_explore(v.Explore),
+            })
+          },
+          Decoder: func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+            return notationGeneralProgrammer_decode_array(notationGeneralProgrammer_decodeArrayProps{
+              Config:  props.Config,
+              Functor: props.Functor,
+              Input:   v.Input,
+              Array:   v.Definition.(*schemametadata.MetadataArray),
+              Explore: notationGeneralProgrammer_feature_explore(v.Explore),
+            })
+          },
+          Empty:   notationGeneralProgrammer_factory.NewIdentifier("[]"),
+          Success: notationGeneralProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+          Failure: func(v nativehelpers.UnionExplorer_ArrayLikeFailureProps) *shimast.Node {
+            return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
+              Context:  props.Context,
+              Functor:  props.Functor,
+              Expected: v.Expected,
+              Input:    v.Input,
+            })
+          },
+        },
+        Parameters: next.Parameters,
+        Input:      next.Input,
+        Arrays:     next.Definitions,
+        Explore:    next.Explore,
+      })
+    },
+    Definitions: props.Arrays,
+    Input:       props.Input,
+    Explore:     props.Explore,
+  })
 }
 
 type notationGeneralProgrammer_arrayLikeFactoryProps[T any] struct {
-	Parameters  []*shimast.Node
-	Input       *shimast.Node
-	Definitions []T
-	Explore     nativeinternal.FeatureProgrammer_IExplore
+  Parameters  []*shimast.Node
+  Input       *shimast.Node
+  Definitions []T
+  Explore     nativeinternal.FeatureProgrammer_IExplore
 }
 
 type notationGeneralProgrammer_exploreArrayLikeUnionTypesProps[T interface {
-	*schemametadata.MetadataArray | *schemametadata.MetadataTuple
+  *schemametadata.MetadataArray | *schemametadata.MetadataTuple
 }] struct {
-	Config      nativeinternal.FeatureProgrammer_IConfig
-	Functor     *nativehelpers.FunctionProgrammer
-	Factory     func(next notationGeneralProgrammer_arrayLikeFactoryProps[T]) *shimast.Node
-	Input       *shimast.Node
-	Definitions []T
-	Explore     nativeinternal.FeatureProgrammer_IExplore
+  Config      nativeinternal.FeatureProgrammer_IConfig
+  Functor     *nativehelpers.FunctionProgrammer
+  Factory     func(next notationGeneralProgrammer_arrayLikeFactoryProps[T]) *shimast.Node
+  Input       *shimast.Node
+  Definitions []T
+  Explore     nativeinternal.FeatureProgrammer_IExplore
 }
 
 func notationGeneralProgrammer_explore_array_like_union_types[T interface {
-	*schemametadata.MetadataArray | *schemametadata.MetadataTuple
+  *schemametadata.MetadataArray | *schemametadata.MetadataTuple
 }](props notationGeneralProgrammer_exploreArrayLikeUnionTypesProps[T]) *shimast.Node {
-	arrow := func(next struct {
-		Parameters []*shimast.Node
-		Explore    nativeinternal.FeatureProgrammer_IExplore
-		Input      *shimast.Node
-	}) *shimast.Node {
-		return props.Factory(notationGeneralProgrammer_arrayLikeFactoryProps[T]{
-			Parameters:  next.Parameters,
-			Definitions: props.Definitions,
-			Explore:     next.Explore,
-			Input:       next.Input,
-		})
-	}
-	arrayExplore := props.Explore
-	arrayExplore.Source = "function"
-	arrayExplore.From = "array"
-	return notationGeneralProgrammer_factory.NewCallExpression(
-		notationGeneralProgrammer_factory.NewIdentifier(props.Functor.EmplaceUnion(props.Config.Prefix, notationGeneralProgrammer_array_like_names(props.Definitions), func() *shimast.Node {
-			explore := arrayExplore
-			explore.Postfix = ""
-			return arrow(struct {
-				Parameters []*shimast.Node
-				Explore    nativeinternal.FeatureProgrammer_IExplore
-				Input      *shimast.Node
-			}{
-				Parameters: nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
-					Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-					Type:   nativefactories.TypeFactory.Keyword("any"),
-					Input:  notationGeneralProgrammer_factory.NewIdentifier("input"),
-				}),
-				Explore: explore,
-				Input:   notationGeneralProgrammer_factory.NewIdentifier("input"),
-			})
-		})),
-		nil,
-		nil,
-		notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
-			Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
-			Explore: arrayExplore,
-			Input:   props.Input,
-		})),
-		shimast.NodeFlagsNone,
-	)
+  arrow := func(next struct {
+    Parameters []*shimast.Node
+    Explore    nativeinternal.FeatureProgrammer_IExplore
+    Input      *shimast.Node
+  }) *shimast.Node {
+    return props.Factory(notationGeneralProgrammer_arrayLikeFactoryProps[T]{
+      Parameters:  next.Parameters,
+      Definitions: props.Definitions,
+      Explore:     next.Explore,
+      Input:       next.Input,
+    })
+  }
+  arrayExplore := props.Explore
+  arrayExplore.Source = "function"
+  arrayExplore.From = "array"
+  return notationGeneralProgrammer_factory.NewCallExpression(
+    notationGeneralProgrammer_factory.NewIdentifier(props.Functor.EmplaceUnion(props.Config.Prefix, notationGeneralProgrammer_array_like_names(props.Definitions), func() *shimast.Node {
+      explore := arrayExplore
+      explore.Postfix = ""
+      return arrow(struct {
+        Parameters []*shimast.Node
+        Explore    nativeinternal.FeatureProgrammer_IExplore
+        Input      *shimast.Node
+      }{
+        Parameters: nativeinternal.FeatureProgrammer.ParameterDeclarations(nativeinternal.FeatureProgrammer_ParameterDeclarationsProps{
+          Config: nativeinternal.FeatureProgrammer_ParameterConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+          Type:   nativefactories.TypeFactory.Keyword("any"),
+          Input:  notationGeneralProgrammer_factory.NewIdentifier("input"),
+        }),
+        Explore: explore,
+        Input:   notationGeneralProgrammer_factory.NewIdentifier("input"),
+      })
+    })),
+    nil,
+    nil,
+    notationGeneralProgrammer_factory.NewNodeList(nativeinternal.FeatureProgrammer.ArgumentsArray(nativeinternal.FeatureProgrammer_ArgumentsArrayProps{
+      Config:  nativeinternal.FeatureProgrammer_ArgumentsArrayConfig{Path: props.Config.Path, Trace: props.Config.Trace},
+      Explore: arrayExplore,
+      Input:   props.Input,
+    })),
+    shimast.NodeFlagsNone,
+  )
 }
 
 func notationGeneralProgrammer_configure(props struct {
-	Rename  NotationGeneralProgrammer_IRename
-	Context nativecontext.ITypiaContext
-	Functor *nativehelpers.FunctionProgrammer
+  Rename  NotationGeneralProgrammer_IRename
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
 }) nativeinternal.FeatureProgrammer_IConfig {
-	var config nativeinternal.FeatureProgrammer_IConfig
-	config = nativeinternal.FeatureProgrammer_IConfig{
-		Types: nativeinternal.FeatureProgrammer_IConfig_ITypes{
-			Input: func(t *shimchecker.Type, name *string) *shimast.TypeNode {
-				return notationGeneralProgrammer_factory.NewTypeReferenceNode(notationGeneralProgrammer_factory.NewIdentifier(notationGeneralProgrammer_type_name(props.Context, t, name)), nil)
-			},
-			Output: func(t *shimchecker.Type, name *string) *shimast.TypeNode {
-				return NotationGeneralProgrammer.ReturnType(NotationGeneralProgrammer_ReturnTypeProps{
-					Rename:  props.Rename,
-					Context: props.Context,
-					Type:    notationGeneralProgrammer_type_name(props.Context, t, name),
-				})
-			},
-		},
-		Prefix:      notationGeneralProgrammer_PREFIX,
-		Trace:       false,
-		Path:        false,
-		Initializer: notationGeneralProgrammer_initializer,
-		Decoder: func(next nativeinternal.FeatureProgrammer_DecoderProps) *shimast.Node {
-			return notationGeneralProgrammer_decode(struct {
-				Config   nativeinternal.FeatureProgrammer_IConfig
-				Rename   NotationGeneralProgrammer_IRename
-				Context  nativecontext.ITypiaContext
-				Functor  *nativehelpers.FunctionProgrammer
-				Metadata *schemametadata.MetadataSchema
-				Explore  nativeinternal.FeatureProgrammer_IExplore
-				Input    *shimast.Node
-			}{Config: config, Rename: props.Rename, Context: props.Context, Functor: props.Functor, Metadata: next.Metadata, Explore: next.Explore, Input: next.Input})
-		},
-		Objector: nativeinternal.FeatureProgrammer_IConfig_IObjector{
-			Checker: func(next nativeinternal.FeatureProgrammer_ObjectorCheckerProps) *shimast.Node {
-				return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
-					Context:  props.Context,
-					Functor:  props.Functor,
-					Input:    next.Input,
-					Metadata: next.Metadata,
-					Explore:  notationGeneralProgrammer_checker_explore(next.Explore),
-				})
-			},
-			Decoder: func(next nativeinternal.FeatureProgrammer_ObjectorDecoderProps) *shimast.Node {
-				return notationGeneralProgrammer_decode_object(struct {
-					Functor *nativehelpers.FunctionProgrammer
-					Object  *schemametadata.MetadataObjectType
-					Input   *shimast.Node
-					Explore nativeinternal.FeatureProgrammer_IExplore
-				}{Functor: props.Functor, Object: next.Object, Input: next.Input, Explore: next.Explore})
-			},
-			Joiner: func(next nativeinternal.FeatureProgrammer_ObjectorJoinerProps) *shimast.Node {
-				return nativehelpers.NotationJoiner.Object(nativehelpers.NotationJoiner_ObjectProps{
-					Rename:  props.Rename.Func,
-					Input:   next.Input,
-					Entries: next.Entries,
-				})
-			},
-			Unionizer: func(next nativeinternal.FeatureProgrammer_ObjectorUnionizerProps) *shimast.Node {
-				return nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{
-					Checker: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
-						return nativeprogrammers.IsProgrammer.Decode_object(nativeprogrammers.IsProgrammer_DecodeObjectProps{
-							Context: props.Context,
-							Functor: props.Functor,
-							Object:  v.Object,
-							Input:   v.Input,
-							Explore: notationGeneralProgrammer_feature_explore(v.Explore),
-						})
-					},
-					Decoder: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
-						return notationGeneralProgrammer_decode_object(struct {
-							Functor *nativehelpers.FunctionProgrammer
-							Object  *schemametadata.MetadataObjectType
-							Input   *shimast.Node
-							Explore nativeinternal.FeatureProgrammer_IExplore
-						}{Functor: props.Functor, Object: v.Object, Input: v.Input, Explore: notationGeneralProgrammer_feature_explore(v.Explore)})
-					},
-					Success: func(exp *shimast.Expression) *shimast.Node {
-						return exp
-					},
-					Escaper: func(v nativeiterate.Decode_union_object_escape) *shimast.Node {
-						return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
-							Context:  props.Context,
-							Functor:  props.Functor,
-							Expected: v.Expected,
-							Input:    v.Input,
-						})
-					},
-					Input:   next.Input,
-					Objects: next.Objects,
-					Explore: next.Explore,
-				})
-			},
-			Failure: func(next nativeinternal.FeatureProgrammer_ObjectorFailureProps) *shimast.Node {
-				return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
-					Context:  props.Context,
-					Functor:  props.Functor,
-					Expected: next.Expected,
-					Input:    next.Input,
-				})
-			},
-		},
-		Generator: nativeinternal.FeatureProgrammer_IConfig_IGenerator{
-			Arrays: func(collection *schemametadata.MetadataCollection) []*shimast.Node {
-				return notationGeneralProgrammer_write_array_functions(struct {
-					Config     nativeinternal.FeatureProgrammer_IConfig
-					Functor    *nativehelpers.FunctionProgrammer
-					Collection *schemametadata.MetadataCollection
-				}{Config: config, Functor: props.Functor, Collection: collection})
-			},
-			Tuples: func(collection *schemametadata.MetadataCollection) []*shimast.Node {
-				return notationGeneralProgrammer_write_tuple_functions(struct {
-					Config     nativeinternal.FeatureProgrammer_IConfig
-					Rename     NotationGeneralProgrammer_IRename
-					Context    nativecontext.ITypiaContext
-					Functor    *nativehelpers.FunctionProgrammer
-					Collection *schemametadata.MetadataCollection
-				}{Config: config, Rename: props.Rename, Context: props.Context, Functor: props.Functor, Collection: collection})
-			},
-		},
-	}
-	return config
+  var config nativeinternal.FeatureProgrammer_IConfig
+  config = nativeinternal.FeatureProgrammer_IConfig{
+    Types: nativeinternal.FeatureProgrammer_IConfig_ITypes{
+      Input: func(t *shimchecker.Type, name *string) *shimast.TypeNode {
+        return notationGeneralProgrammer_factory.NewTypeReferenceNode(notationGeneralProgrammer_factory.NewIdentifier(notationGeneralProgrammer_type_name(props.Context, t, name)), nil)
+      },
+      Output: func(t *shimchecker.Type, name *string) *shimast.TypeNode {
+        return NotationGeneralProgrammer.ReturnType(NotationGeneralProgrammer_ReturnTypeProps{
+          Rename:  props.Rename,
+          Context: props.Context,
+          Type:    notationGeneralProgrammer_type_name(props.Context, t, name),
+        })
+      },
+    },
+    Prefix:      notationGeneralProgrammer_PREFIX,
+    Trace:       false,
+    Path:        false,
+    Initializer: notationGeneralProgrammer_initializer,
+    Decoder: func(next nativeinternal.FeatureProgrammer_DecoderProps) *shimast.Node {
+      return notationGeneralProgrammer_decode(struct {
+        Config   nativeinternal.FeatureProgrammer_IConfig
+        Rename   NotationGeneralProgrammer_IRename
+        Context  nativecontext.ITypiaContext
+        Functor  *nativehelpers.FunctionProgrammer
+        Metadata *schemametadata.MetadataSchema
+        Explore  nativeinternal.FeatureProgrammer_IExplore
+        Input    *shimast.Node
+      }{Config: config, Rename: props.Rename, Context: props.Context, Functor: props.Functor, Metadata: next.Metadata, Explore: next.Explore, Input: next.Input})
+    },
+    Objector: nativeinternal.FeatureProgrammer_IConfig_IObjector{
+      Checker: func(next nativeinternal.FeatureProgrammer_ObjectorCheckerProps) *shimast.Node {
+        return nativeprogrammers.IsProgrammer.Decode(nativeprogrammers.IsProgrammer_DecodeProps{
+          Context:  props.Context,
+          Functor:  props.Functor,
+          Input:    next.Input,
+          Metadata: next.Metadata,
+          Explore:  notationGeneralProgrammer_checker_explore(next.Explore),
+        })
+      },
+      Decoder: func(next nativeinternal.FeatureProgrammer_ObjectorDecoderProps) *shimast.Node {
+        return notationGeneralProgrammer_decode_object(struct {
+          Functor *nativehelpers.FunctionProgrammer
+          Object  *schemametadata.MetadataObjectType
+          Input   *shimast.Node
+          Explore nativeinternal.FeatureProgrammer_IExplore
+        }{Functor: props.Functor, Object: next.Object, Input: next.Input, Explore: next.Explore})
+      },
+      Joiner: func(next nativeinternal.FeatureProgrammer_ObjectorJoinerProps) *shimast.Node {
+        return nativehelpers.NotationJoiner.Object(nativehelpers.NotationJoiner_ObjectProps{
+          Rename:  props.Rename.Func,
+          Input:   next.Input,
+          Entries: next.Entries,
+        })
+      },
+      Unionizer: func(next nativeinternal.FeatureProgrammer_ObjectorUnionizerProps) *shimast.Node {
+        return nativeiterate.Decode_union_object(nativeiterate.Decode_union_objectProps{
+          Checker: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
+            return nativeprogrammers.IsProgrammer.Decode_object(nativeprogrammers.IsProgrammer_DecodeObjectProps{
+              Context: props.Context,
+              Functor: props.Functor,
+              Object:  v.Object,
+              Input:   v.Input,
+              Explore: notationGeneralProgrammer_feature_explore(v.Explore),
+            })
+          },
+          Decoder: func(v nativeiterate.Decode_union_object_next) *shimast.Node {
+            return notationGeneralProgrammer_decode_object(struct {
+              Functor *nativehelpers.FunctionProgrammer
+              Object  *schemametadata.MetadataObjectType
+              Input   *shimast.Node
+              Explore nativeinternal.FeatureProgrammer_IExplore
+            }{Functor: props.Functor, Object: v.Object, Input: v.Input, Explore: notationGeneralProgrammer_feature_explore(v.Explore)})
+          },
+          Success: func(exp *shimast.Expression) *shimast.Node {
+            return exp
+          },
+          Escaper: func(v nativeiterate.Decode_union_object_escape) *shimast.Node {
+            return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
+              Context:  props.Context,
+              Functor:  props.Functor,
+              Expected: v.Expected,
+              Input:    v.Input,
+            })
+          },
+          Input:   next.Input,
+          Objects: next.Objects,
+          Explore: next.Explore,
+        })
+      },
+      Failure: func(next nativeinternal.FeatureProgrammer_ObjectorFailureProps) *shimast.Node {
+        return notationGeneralProgrammer_create_throw_error(notationGeneralProgrammer_throwProps{
+          Context:  props.Context,
+          Functor:  props.Functor,
+          Expected: next.Expected,
+          Input:    next.Input,
+        })
+      },
+    },
+    Generator: nativeinternal.FeatureProgrammer_IConfig_IGenerator{
+      Arrays: func(collection *schemametadata.MetadataCollection) []*shimast.Node {
+        return notationGeneralProgrammer_write_array_functions(struct {
+          Config     nativeinternal.FeatureProgrammer_IConfig
+          Functor    *nativehelpers.FunctionProgrammer
+          Collection *schemametadata.MetadataCollection
+        }{Config: config, Functor: props.Functor, Collection: collection})
+      },
+      Tuples: func(collection *schemametadata.MetadataCollection) []*shimast.Node {
+        return notationGeneralProgrammer_write_tuple_functions(struct {
+          Config     nativeinternal.FeatureProgrammer_IConfig
+          Rename     NotationGeneralProgrammer_IRename
+          Context    nativecontext.ITypiaContext
+          Functor    *nativehelpers.FunctionProgrammer
+          Collection *schemametadata.MetadataCollection
+        }{Config: config, Rename: props.Rename, Context: props.Context, Functor: props.Functor, Collection: collection})
+      },
+    },
+  }
+  return config
 }
 
 func notationGeneralProgrammer_initializer(props nativeinternal.FeatureProgrammer_InitializerProps) nativeinternal.FeatureProgrammer_InitializerOutput {
-	collection := schemametadata.NewMetadataCollection()
-	result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-		Checker:     props.Context.Checker,
-		Transformer: props.Context.Transformer,
-		Options: nativefactories.MetadataFactory_IOptions{
-			Escape:   false,
-			Constant: true,
-			Absorb:   true,
-		},
-		Components: collection,
-		Type:       props.Type,
-	})
-	if result.Success == false {
-		panic(nativecontext.TransformerError_from(struct {
-			Code   string
-			Errors []nativecontext.TransformerError_MetadataFactory_IError
-		}{
-			Code:   props.Functor.Method,
-			Errors: notationGeneralProgrammer_errors(result.Errors),
-		}))
-	}
-	return nativeinternal.FeatureProgrammer_InitializerOutput{
-		Collection: collection,
-		Metadata:   result.Data,
-	}
+  collection := schemametadata.NewMetadataCollection()
+  result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+    Checker:     props.Context.Checker,
+    Transformer: props.Context.Transformer,
+    Options: nativefactories.MetadataFactory_IOptions{
+      Escape:   false,
+      Constant: true,
+      Absorb:   true,
+    },
+    Components: collection,
+    Type:       props.Type,
+  })
+  if result.Success == false {
+    panic(nativecontext.TransformerError_from(struct {
+      Code   string
+      Errors []nativecontext.TransformerError_MetadataFactory_IError
+    }{
+      Code:   props.Functor.Method,
+      Errors: notationGeneralProgrammer_errors(result.Errors),
+    }))
+  }
+  return nativeinternal.FeatureProgrammer_InitializerOutput{
+    Collection: collection,
+    Metadata:   result.Data,
+  }
 }
 
 type notationGeneralProgrammer_throwProps struct {
-	Context  nativecontext.ITypiaContext
-	Functor  *nativehelpers.FunctionProgrammer
-	Expected string
-	Input    *shimast.Node
+  Context  nativecontext.ITypiaContext
+  Functor  *nativehelpers.FunctionProgrammer
+  Expected string
+  Input    *shimast.Node
 }
 
 func notationGeneralProgrammer_create_throw_error(props notationGeneralProgrammer_throwProps) *shimast.Node {
-	return notationGeneralProgrammer_factory.NewExpressionStatement(
-		notationGeneralProgrammer_factory.NewCallExpression(
-			notationGeneralProgrammer_internal(props.Context, "throwTypeGuardError"),
-			nil,
-			notationGeneralProgrammer_factory.NewNodeList(nil),
-			notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-				notationGeneralProgrammer_factory.NewObjectLiteralExpression(
-					notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-						notationGeneralProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("method"), nil, nil, notationGeneralProgrammer_factory.NewStringLiteral(props.Functor.Method, shimast.TokenFlagsNone)),
-						notationGeneralProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("expected"), nil, nil, notationGeneralProgrammer_factory.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)),
-						notationGeneralProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("value"), nil, nil, props.Input),
-					}),
-					true,
-				),
-			}),
-			shimast.NodeFlagsNone,
-		),
-	)
+  return notationGeneralProgrammer_factory.NewExpressionStatement(
+    notationGeneralProgrammer_factory.NewCallExpression(
+      notationGeneralProgrammer_internal(props.Context, "throwTypeGuardError"),
+      nil,
+      notationGeneralProgrammer_factory.NewNodeList(nil),
+      notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+        notationGeneralProgrammer_factory.NewObjectLiteralExpression(
+          notationGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+            notationGeneralProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("method"), nil, nil, notationGeneralProgrammer_factory.NewStringLiteral(props.Functor.Method, shimast.TokenFlagsNone)),
+            notationGeneralProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("expected"), nil, nil, notationGeneralProgrammer_factory.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)),
+            notationGeneralProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("value"), nil, nil, props.Input),
+          }),
+          true,
+        ),
+      }),
+      shimast.NodeFlagsNone,
+    ),
+  )
 }
 
 func notationGeneralProgrammer_is_instance(metadata *schemametadata.MetadataSchema) bool {
-	return len(metadata.Objects) != 0 ||
-		len(metadata.Arrays) != 0 ||
-		len(metadata.Tuples) != 0 ||
-		len(metadata.Sets) != 0 ||
-		len(metadata.Maps) != 0 ||
-		len(metadata.Natives) != 0 ||
-		(metadata.Rest != nil && notationGeneralProgrammer_is_instance(metadata.Rest))
+  return len(metadata.Objects) != 0 ||
+    len(metadata.Arrays) != 0 ||
+    len(metadata.Tuples) != 0 ||
+    len(metadata.Sets) != 0 ||
+    len(metadata.Maps) != 0 ||
+    len(metadata.Natives) != 0 ||
+    (metadata.Rest != nil && notationGeneralProgrammer_is_instance(metadata.Rest))
 }
 
 type notationGeneralProgrammer_IUnion struct {
-	Type  string
-	Is    func() *shimast.Node
-	Value func() *shimast.Node
+  Type  string
+  Is    func() *shimast.Node
+  Value func() *shimast.Node
 }
 
 func notationGeneralProgrammer_binary(left *shimast.Node, operator shimast.Kind, right *shimast.Node) *shimast.Node {
-	return notationGeneralProgrammer_factory.NewBinaryExpression(nil, left, nil, notationGeneralProgrammer_factory.NewToken(operator), right)
+  return notationGeneralProgrammer_factory.NewBinaryExpression(nil, left, nil, notationGeneralProgrammer_factory.NewToken(operator), right)
 }
 
 func notationGeneralProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
-	if importer, ok := context.Importer.(interface{ Internal(string) *shimast.Node }); ok {
-		return importer.Internal(name)
-	}
-	return notationGeneralProgrammer_factory.NewIdentifier(name)
+  if importer, ok := context.Importer.(interface{ Internal(string) *shimast.Node }); ok {
+    return importer.Internal(name)
+  }
+  return notationGeneralProgrammer_factory.NewIdentifier(name)
 }
 
 func notationGeneralProgrammer_import_type(context nativecontext.ITypiaContext, props nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node {
-	if importer, ok := context.Importer.(interface {
-		Type(nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node
-	}); ok {
-		return importer.Type(props)
-	}
-	if str, ok := props.Name.(string); ok {
-		return notationGeneralProgrammer_factory.NewTypeReferenceNode(notationGeneralProgrammer_factory.NewIdentifier(str), notationGeneralProgrammer_factory.NewNodeList(props.Arguments))
-	}
-	return props.Name.(*shimast.Node)
+  if importer, ok := context.Importer.(interface {
+    Type(nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node
+  }); ok {
+    return importer.Type(props)
+  }
+  if str, ok := props.Name.(string); ok {
+    return notationGeneralProgrammer_factory.NewTypeReferenceNode(notationGeneralProgrammer_factory.NewIdentifier(str), notationGeneralProgrammer_factory.NewNodeList(props.Arguments))
+  }
+  return props.Name.(*shimast.Node)
 }
 
 func notationGeneralProgrammer_type_name(context nativecontext.ITypiaContext, typ *shimchecker.Type, name *string) string {
-	if name != nil {
-		return *name
-	}
-	return nativefactories.TypeFactory.GetFullName(nativefactories.TypeFactory_GetFullNameProps{
-		Checker: context.Checker,
-		Type:    typ,
-	})
+  if name != nil {
+    return *name
+  }
+  return nativefactories.TypeFactory.GetFullName(nativefactories.TypeFactory_GetFullNameProps{
+    Checker: context.Checker,
+    Type:    typ,
+  })
 }
 
 func notationGeneralProgrammer_method_text(modulo *shimast.Node) string {
-	if modulo == nil {
-		return ""
-	}
-	return modulo.Text()
+  if modulo == nil {
+    return ""
+  }
+  return modulo.Text()
 }
 
 func notationGeneralProgrammer_feature_explore(input any) nativeinternal.FeatureProgrammer_IExplore {
-	switch v := input.(type) {
-	case nativeinternal.FeatureProgrammer_IExplore:
-		return v
-	case *nativeinternal.FeatureProgrammer_IExplore:
-		return *v
-	default:
-		return nativeinternal.FeatureProgrammer_IExplore{}
-	}
+  switch v := input.(type) {
+  case nativeinternal.FeatureProgrammer_IExplore:
+    return v
+  case *nativeinternal.FeatureProgrammer_IExplore:
+    return *v
+  default:
+    return nativeinternal.FeatureProgrammer_IExplore{}
+  }
 }
 
 func notationGeneralProgrammer_checker_explore(input any) nativeinternal.CheckerProgrammer_IExplore {
-	v := notationGeneralProgrammer_feature_explore(input)
-	return nativeinternal.CheckerProgrammer_IExplore{
-		Tracable: v.Tracable,
-		Source:   v.Source,
-		From:     v.From,
-		Postfix:  v.Postfix,
-		Start:    v.Start,
-	}
+  v := notationGeneralProgrammer_feature_explore(input)
+  return nativeinternal.CheckerProgrammer_IExplore{
+    Tracable: v.Tracable,
+    Source:   v.Source,
+    From:     v.From,
+    Postfix:  v.Postfix,
+    Start:    v.Start,
+  }
 }
 
 func notationGeneralProgrammer_checker_explore_with_postfix(input any, postfix string) nativeinternal.CheckerProgrammer_IExplore {
-	v := notationGeneralProgrammer_checker_explore(input)
-	v.Postfix = v.Postfix + postfix
-	return v
+  v := notationGeneralProgrammer_checker_explore(input)
+  v.Postfix = v.Postfix + postfix
+  return v
 }
 
 func notationGeneralProgrammer_explore_with(explore nativeinternal.FeatureProgrammer_IExplore, source string, from string) nativeinternal.FeatureProgrammer_IExplore {
-	explore.Source = source
-	explore.From = from
-	return explore
+  explore.Source = source
+  explore.From = from
+  return explore
 }
 
 func notationGeneralProgrammer_errors(errors []nativefactories.MetadataFactory_IError) []nativecontext.TransformerError_MetadataFactory_IError {
-	output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
-	for _, err := range errors {
-		output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
-			Name: err.Name,
-			Explore: nativecontext.TransformerError_MetadataFactory_IExplore{
-				Object:    err.Explore.Object,
-				Property:  err.Explore.Property,
-				Parameter: err.Explore.Parameter,
-				Output:    err.Explore.Output,
-			},
-			Messages: append([]string{}, err.Messages...),
-		})
-	}
-	return output
+  output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
+  for _, err := range errors {
+    output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
+      Name: err.Name,
+      Explore: nativecontext.TransformerError_MetadataFactory_IExplore{
+        Object:    err.Explore.Object,
+        Property:  err.Explore.Property,
+        Parameter: err.Explore.Parameter,
+        Output:    err.Explore.Output,
+      },
+      Messages: append([]string{}, err.Messages...),
+    })
+  }
+  return output
 }
 
 func notationGeneralProgrammer_some_arrays(values []*schemametadata.MetadataArray, pred func(*schemametadata.MetadataArray) bool) bool {
-	for _, value := range values {
-		if pred(value) {
-			return true
-		}
-	}
-	return false
+  for _, value := range values {
+    if pred(value) {
+      return true
+    }
+  }
+  return false
 }
 
 func notationGeneralProgrammer_some_tuples(values []*schemametadata.MetadataTuple, pred func(*schemametadata.MetadataTuple) bool) bool {
-	for _, value := range values {
-		if pred(value) {
-			return true
-		}
-	}
-	return false
+  for _, value := range values {
+    if pred(value) {
+      return true
+    }
+  }
+  return false
 }
 
 func notationGeneralProgrammer_every_schema(values []*schemametadata.MetadataSchema, pred func(*schemametadata.MetadataSchema) bool) bool {
-	if len(values) == 0 {
-		return false
-	}
-	for _, value := range values {
-		if pred(value) == false {
-			return false
-		}
-	}
-	return true
+  if len(values) == 0 {
+    return false
+  }
+  for _, value := range values {
+    if pred(value) == false {
+      return false
+    }
+  }
+  return true
 }
 
 func notationGeneralProgrammer_array_like_names[T interface {
-	*schemametadata.MetadataArray | *schemametadata.MetadataTuple
+  *schemametadata.MetadataArray | *schemametadata.MetadataTuple
 }](values []T) string {
-	names := make([]string, 0, len(values))
-	for _, value := range values {
-		switch typed := any(value).(type) {
-		case *schemametadata.MetadataArray:
-			names = append(names, typed.Type.Name)
-		case *schemametadata.MetadataTuple:
-			names = append(names, typed.Type.Name)
-		}
-	}
-	return strings.Join(names, " | ")
+  names := make([]string, 0, len(values))
+  for _, value := range values {
+    switch typed := any(value).(type) {
+    case *schemametadata.MetadataArray:
+      names = append(names, typed.Type.Name)
+    case *schemametadata.MetadataTuple:
+      names = append(names, typed.Type.Name)
+    }
+  }
+  return strings.Join(names, " | ")
 }
 
 func notationGeneralProgrammer_merge_functions(groups ...map[string]*shimast.Node) map[string]*shimast.Node {
-	output := map[string]*shimast.Node{}
-	for _, group := range groups {
-		for key, value := range group {
-			output[key] = value
-		}
-	}
-	return output
+  output := map[string]*shimast.Node{}
+  for _, group := range groups {
+    for key, value := range group {
+      output[key] = value
+    }
+  }
+  return output
 }
 
 func notationGeneralProgrammer_capitalize(str string) string {
-	if str == "" {
-		return str
-	}
-	return strings.ToUpper(str[:1]) + str[1:]
+  if str == "" {
+    return str
+  }
+  return strings.ToUpper(str[:1]) + str[1:]
 }
 
 var NotationGeneralProgrammer_Camel = NotationGeneralProgrammer_IRename{Name: "camel", Func: notationGeneralProgrammer_camel}
@@ -1274,108 +1274,108 @@ var NotationGeneralProgrammer_Pascal = NotationGeneralProgrammer_IRename{Name: "
 var NotationGeneralProgrammer_Snake = NotationGeneralProgrammer_IRename{Name: "snake", Func: notationGeneralProgrammer_snake}
 
 func notationGeneralProgrammer_camel(str string) string {
-	return notationGeneralProgrammer_unsnake(str, func(value string) string {
-		if value == "" {
-			return value
-		}
-		if value == strings.ToUpper(value) {
-			return strings.ToLower(value)
-		}
-		return strings.ToLower(value[:1]) + value[1:]
-	}, func(value string, index int) string {
-		if index == 0 {
-			return strings.ToLower(value)
-		}
-		return notationGeneralProgrammer_capitalize(strings.ToLower(value))
-	})
+  return notationGeneralProgrammer_unsnake(str, func(value string) string {
+    if value == "" {
+      return value
+    }
+    if value == strings.ToUpper(value) {
+      return strings.ToLower(value)
+    }
+    return strings.ToLower(value[:1]) + value[1:]
+  }, func(value string, index int) string {
+    if index == 0 {
+      return strings.ToLower(value)
+    }
+    return notationGeneralProgrammer_capitalize(strings.ToLower(value))
+  })
 }
 
 func notationGeneralProgrammer_pascal(str string) string {
-	return notationGeneralProgrammer_unsnake(str, func(value string) string {
-		if value == "" {
-			return value
-		}
-		return strings.ToUpper(value[:1]) + value[1:]
-	}, func(value string, index int) string {
-		return notationGeneralProgrammer_capitalize(value)
-	})
+  return notationGeneralProgrammer_unsnake(str, func(value string) string {
+    if value == "" {
+      return value
+    }
+    return strings.ToUpper(value[:1]) + value[1:]
+  }, func(value string, index int) string {
+    return notationGeneralProgrammer_capitalize(value)
+  })
 }
 
 func notationGeneralProgrammer_snake(str string) string {
-	if str == "" {
-		return str
-	}
-	prefix := ""
-	for len(str) != 0 && str[0] == '_' {
-		prefix += "_"
-		str = str[1:]
-	}
-	out := func(value string) string { return prefix + value }
-	items := strings.Split(str, "_")
-	if len(items) > 1 {
-		for i, item := range items {
-			items[i] = strings.ToLower(item)
-		}
-		return out(strings.Join(items, "_"))
-	}
-	indexes := []int{}
-	for i := 0; i < len(str); i++ {
-		code := str[i]
-		if 'A' <= code && code <= 'Z' {
-			indexes = append(indexes, i)
-		}
-	}
-	for i := len(indexes) - 1; i > 0; i-- {
-		now := indexes[i]
-		prev := indexes[i-1]
-		if now-prev == 1 {
-			indexes = append(indexes[:i], indexes[i+1:]...)
-		}
-	}
-	if len(indexes) != 0 && indexes[0] == 0 {
-		indexes = indexes[1:]
-	}
-	if len(indexes) == 0 {
-		return strings.ToLower(str)
-	}
-	ret := ""
-	for i, last := range indexes {
-		first := 0
-		if i != 0 {
-			first = indexes[i-1]
-		}
-		ret += strings.ToLower(str[first:last])
-		ret += "_"
-	}
-	ret += strings.ToLower(str[indexes[len(indexes)-1]:])
-	return out(ret)
+  if str == "" {
+    return str
+  }
+  prefix := ""
+  for len(str) != 0 && str[0] == '_' {
+    prefix += "_"
+    str = str[1:]
+  }
+  out := func(value string) string { return prefix + value }
+  items := strings.Split(str, "_")
+  if len(items) > 1 {
+    for i, item := range items {
+      items[i] = strings.ToLower(item)
+    }
+    return out(strings.Join(items, "_"))
+  }
+  indexes := []int{}
+  for i := 0; i < len(str); i++ {
+    code := str[i]
+    if 'A' <= code && code <= 'Z' {
+      indexes = append(indexes, i)
+    }
+  }
+  for i := len(indexes) - 1; i > 0; i-- {
+    now := indexes[i]
+    prev := indexes[i-1]
+    if now-prev == 1 {
+      indexes = append(indexes[:i], indexes[i+1:]...)
+    }
+  }
+  if len(indexes) != 0 && indexes[0] == 0 {
+    indexes = indexes[1:]
+  }
+  if len(indexes) == 0 {
+    return strings.ToLower(str)
+  }
+  ret := ""
+  for i, last := range indexes {
+    first := 0
+    if i != 0 {
+      first = indexes[i-1]
+    }
+    ret += strings.ToLower(str[first:last])
+    ret += "_"
+  }
+  ret += strings.ToLower(str[indexes[len(indexes)-1]:])
+  return out(ret)
 }
 
 func notationGeneralProgrammer_unsnake(str string, plain func(string) string, snake func(string, int) string) string {
-	prefix := ""
-	for len(str) != 0 && str[0] == '_' {
-		prefix += "_"
-		str = str[1:]
-	}
-	out := func(value string) string { return prefix + value }
-	if str == "" {
-		return out("")
-	}
-	raw := strings.Split(str, "_")
-	items := []string{}
-	for _, item := range raw {
-		if item != "" {
-			items = append(items, item)
-		}
-	}
-	if len(items) == 0 {
-		return out("")
-	}
-	if len(items) == 1 {
-		return out(plain(items[0]))
-	}
-	for i, item := range items {
-		items[i] = snake(item, i)
-	}
-	return out(strings.Join(items, ""))
+  prefix := ""
+  for len(str) != 0 && str[0] == '_' {
+    prefix += "_"
+    str = str[1:]
+  }
+  out := func(value string) string { return prefix + value }
+  if str == "" {
+    return out("")
+  }
+  raw := strings.Split(str, "_")
+  items := []string{}
+  for _, item := range raw {
+    if item != "" {
+      items = append(items, item)
+    }
+  }
+  if len(items) == 0 {
+    return out("")
+  }
+  if len(items) == 1 {
+    return out(plain(items[0]))
+  }
+  for i, item := range items {
+    items[i] = snake(item, i)
+  }
+  return out(strings.Join(items, ""))
 }