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

package/native/core/programmers/misc/MiscValidateCloneProgrammer.go

@@ -1,13 +1,13 @@
 package misc
 
 import (
-	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"
+  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"
 )
 
 type miscValidateCloneProgrammerNamespace struct{}
@@ -15,108 +15,108 @@ type miscValidateCloneProgrammerNamespace struct{}
 var MiscValidateCloneProgrammer = miscValidateCloneProgrammerNamespace{}
 
 type MiscValidateCloneProgrammer_DecomposeProps struct {
-	Context nativecontext.ITypiaContext
-	Modulo  *shimast.Node
-	Functor *nativehelpers.FunctionProgrammer
-	Type    *shimchecker.Type
-	Name    *string
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
 }
 
 var miscValidateCloneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (miscValidateCloneProgrammerNamespace) Decompose(props MiscValidateCloneProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-	validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
-		Context: props.Context,
-		Modulo:  props.Modulo,
-		Functor: props.Functor,
-		Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
-		Type:    props.Type,
-		Name:    props.Name,
-	})
-	clone := MiscCloneProgrammer.Decompose(MiscCloneProgrammer_DecomposeProps{
-		Context:   props.Context,
-		Functor:   props.Functor,
-		Type:      props.Type,
-		Name:      props.Name,
-		Validated: true,
-	})
-	statements := append([]*shimast.Node{}, validate.Statements...)
-	statements = append(statements, clone.Statements...)
-	statements = append(statements,
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__validate", Value: validate.Arrow}),
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__clone", Value: clone.Arrow}),
-	)
-	cloneType := clone.Arrow.AsArrowFunction().Type
-	if cloneType == nil {
-		cloneType = nativefactories.TypeFactory.Keyword("any")
-	}
-	return nativeinternal.FeatureProgrammer_IDecomposed{
-		Functions:  miscProgrammer_merge_functions(validate.Functions, clone.Functions),
-		Statements: statements,
-		Arrow: miscValidateCloneProgrammer_factory.NewArrowFunction(
-			nil,
-			nil,
-			miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{
-				nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
-			}),
-			miscCloneProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
-				File:      "typia",
-				Name:      "IValidation",
-				Arguments: []*shimast.TypeNode{cloneType},
-			}),
-			nil,
-			miscValidateCloneProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			miscValidateCloneProgrammer_factory.NewBlock(miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{
-				nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-					Name: "result",
-					Value: miscValidateCloneProgrammer_factory.NewAsExpression(
-						miscValidateCloneProgrammer_factory.NewCallExpression(
-							miscValidateCloneProgrammer_factory.NewIdentifier("__validate"),
-							nil,
-							nil,
-							miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidateCloneProgrammer_factory.NewIdentifier("input")}),
-							shimast.NodeFlagsNone,
-						),
-						nativefactories.TypeFactory.Keyword("any"),
-					),
-				}),
-				miscValidateCloneProgrammer_factory.NewIfStatement(
-					miscValidateCloneProgrammer_factory.NewIdentifier("result.success"),
-					miscValidateCloneProgrammer_factory.NewExpressionStatement(
-						miscValidateCloneProgrammer_factory.NewBinaryExpression(
-							nil,
-							miscValidateCloneProgrammer_factory.NewIdentifier("result.data"),
-							nil,
-							miscValidateCloneProgrammer_factory.NewToken(shimast.KindEqualsToken),
-							miscValidateCloneProgrammer_factory.NewCallExpression(
-								miscValidateCloneProgrammer_factory.NewIdentifier("__clone"),
-								nil,
-								nil,
-								miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidateCloneProgrammer_factory.NewIdentifier("input")}),
-								shimast.NodeFlagsNone,
-							),
-						),
-					),
-					nil,
-				),
-				miscValidateCloneProgrammer_factory.NewReturnStatement(miscValidateCloneProgrammer_factory.NewIdentifier("result")),
-			}), true),
-		),
-	}
+  validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Functor: props.Functor,
+    Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  clone := MiscCloneProgrammer.Decompose(MiscCloneProgrammer_DecomposeProps{
+    Context:   props.Context,
+    Functor:   props.Functor,
+    Type:      props.Type,
+    Name:      props.Name,
+    Validated: true,
+  })
+  statements := append([]*shimast.Node{}, validate.Statements...)
+  statements = append(statements, clone.Statements...)
+  statements = append(statements,
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__validate", Value: validate.Arrow}),
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__clone", Value: clone.Arrow}),
+  )
+  cloneType := clone.Arrow.AsArrowFunction().Type
+  if cloneType == nil {
+    cloneType = nativefactories.TypeFactory.Keyword("any")
+  }
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  miscProgrammer_merge_functions(validate.Functions, clone.Functions),
+    Statements: statements,
+    Arrow: miscValidateCloneProgrammer_factory.NewArrowFunction(
+      nil,
+      nil,
+      miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{
+        nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
+      }),
+      miscCloneProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+        File:      "typia",
+        Name:      "IValidation",
+        Arguments: []*shimast.TypeNode{cloneType},
+      }),
+      nil,
+      miscValidateCloneProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      miscValidateCloneProgrammer_factory.NewBlock(miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{
+        nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+          Name: "result",
+          Value: miscValidateCloneProgrammer_factory.NewAsExpression(
+            miscValidateCloneProgrammer_factory.NewCallExpression(
+              miscValidateCloneProgrammer_factory.NewIdentifier("__validate"),
+              nil,
+              nil,
+              miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidateCloneProgrammer_factory.NewIdentifier("input")}),
+              shimast.NodeFlagsNone,
+            ),
+            nativefactories.TypeFactory.Keyword("any"),
+          ),
+        }),
+        miscValidateCloneProgrammer_factory.NewIfStatement(
+          miscValidateCloneProgrammer_factory.NewIdentifier("result.success"),
+          miscValidateCloneProgrammer_factory.NewExpressionStatement(
+            miscValidateCloneProgrammer_factory.NewBinaryExpression(
+              nil,
+              miscValidateCloneProgrammer_factory.NewIdentifier("result.data"),
+              nil,
+              miscValidateCloneProgrammer_factory.NewToken(shimast.KindEqualsToken),
+              miscValidateCloneProgrammer_factory.NewCallExpression(
+                miscValidateCloneProgrammer_factory.NewIdentifier("__clone"),
+                nil,
+                nil,
+                miscValidateCloneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidateCloneProgrammer_factory.NewIdentifier("input")}),
+                shimast.NodeFlagsNone,
+              ),
+            ),
+          ),
+          nil,
+        ),
+        miscValidateCloneProgrammer_factory.NewReturnStatement(miscValidateCloneProgrammer_factory.NewIdentifier("result")),
+      }), true),
+    ),
+  }
 }
 
 func (miscValidateCloneProgrammerNamespace) Write(props nativecontext.IProgrammerProps) *shimast.Node {
-	functor := nativehelpers.NewFunctionProgrammer(miscCloneProgrammer_method_text(props.Modulo))
-	result := MiscValidateCloneProgrammer.Decompose(MiscValidateCloneProgrammer_DecomposeProps{
-		Context: props.Context,
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Type:    props.Type,
-		Name:    props.Name,
-	})
-	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Result:  result,
-	})
+  functor := nativehelpers.NewFunctionProgrammer(miscCloneProgrammer_method_text(props.Modulo))
+  result := MiscValidateCloneProgrammer.Decompose(MiscValidateCloneProgrammer_DecomposeProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
 }

package/native/core/programmers/misc/MiscValidatePruneProgrammer.go

@@ -1,13 +1,13 @@
 package misc
 
 import (
-	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"
+  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"
 )
 
 type miscValidatePruneProgrammerNamespace struct{}
@@ -15,99 +15,99 @@ type miscValidatePruneProgrammerNamespace struct{}
 var MiscValidatePruneProgrammer = miscValidatePruneProgrammerNamespace{}
 
 type MiscValidatePruneProgrammer_DecomposeProps struct {
-	Context nativecontext.ITypiaContext
-	Modulo  *shimast.Node
-	Functor *nativehelpers.FunctionProgrammer
-	Type    *shimchecker.Type
-	Name    *string
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
 }
 
 var miscValidatePruneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (miscValidatePruneProgrammerNamespace) Decompose(props MiscValidatePruneProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-	validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
-		Context: props.Context,
-		Modulo:  props.Modulo,
-		Functor: props.Functor,
-		Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
-		Type:    props.Type,
-		Name:    props.Name,
-	})
-	prune := MiscPruneProgrammer.Decompose(MiscPruneProgrammer_DecomposeProps{
-		Context:   props.Context,
-		Functor:   props.Functor,
-		Type:      props.Type,
-		Name:      props.Name,
-		Validated: true,
-	})
-	statements := append([]*shimast.Node{}, validate.Statements...)
-	statements = append(statements, prune.Statements...)
-	statements = append(statements,
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__validate", Value: validate.Arrow}),
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__prune", Value: prune.Arrow}),
-	)
-	pruneType := miscValidatePruneProgrammer_factory.NewTypeReferenceNode(
-		miscValidatePruneProgrammer_factory.NewIdentifier(miscCloneProgrammer_type_name(props.Context, props.Type, props.Name)),
-		nil,
-	)
-	return nativeinternal.FeatureProgrammer_IDecomposed{
-		Functions:  miscProgrammer_merge_functions(validate.Functions, prune.Functions),
-		Statements: statements,
-		Arrow: miscValidatePruneProgrammer_factory.NewArrowFunction(
-			nil,
-			nil,
-			miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{
-				nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
-			}),
-			miscCloneProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
-				File:      "typia",
-				Name:      "IValidation",
-				Arguments: []*shimast.TypeNode{pruneType},
-			}),
-			nil,
-			miscValidatePruneProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			miscValidatePruneProgrammer_factory.NewBlock(miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{
-				nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-					Name: "result",
-					Value: miscValidatePruneProgrammer_factory.NewCallExpression(
-						miscValidatePruneProgrammer_factory.NewIdentifier("__validate"),
-						nil,
-						nil,
-						miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidatePruneProgrammer_factory.NewIdentifier("input")}),
-						shimast.NodeFlagsNone,
-					),
-				}),
-				miscValidatePruneProgrammer_factory.NewIfStatement(
-					miscValidatePruneProgrammer_factory.NewIdentifier("result.success"),
-					miscValidatePruneProgrammer_factory.NewExpressionStatement(
-						miscValidatePruneProgrammer_factory.NewCallExpression(
-							miscValidatePruneProgrammer_factory.NewIdentifier("__prune"),
-							nil,
-							nil,
-							miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidatePruneProgrammer_factory.NewIdentifier("input")}),
-							shimast.NodeFlagsNone,
-						),
-					),
-					nil,
-				),
-				miscValidatePruneProgrammer_factory.NewReturnStatement(miscValidatePruneProgrammer_factory.NewIdentifier("result")),
-			}), true),
-		),
-	}
+  validate := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Functor: props.Functor,
+    Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: false},
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  prune := MiscPruneProgrammer.Decompose(MiscPruneProgrammer_DecomposeProps{
+    Context:   props.Context,
+    Functor:   props.Functor,
+    Type:      props.Type,
+    Name:      props.Name,
+    Validated: true,
+  })
+  statements := append([]*shimast.Node{}, validate.Statements...)
+  statements = append(statements, prune.Statements...)
+  statements = append(statements,
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__validate", Value: validate.Arrow}),
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__prune", Value: prune.Arrow}),
+  )
+  pruneType := miscValidatePruneProgrammer_factory.NewTypeReferenceNode(
+    miscValidatePruneProgrammer_factory.NewIdentifier(miscCloneProgrammer_type_name(props.Context, props.Type, props.Name)),
+    nil,
+  )
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  miscProgrammer_merge_functions(validate.Functions, prune.Functions),
+    Statements: statements,
+    Arrow: miscValidatePruneProgrammer_factory.NewArrowFunction(
+      nil,
+      nil,
+      miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{
+        nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
+      }),
+      miscCloneProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+        File:      "typia",
+        Name:      "IValidation",
+        Arguments: []*shimast.TypeNode{pruneType},
+      }),
+      nil,
+      miscValidatePruneProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      miscValidatePruneProgrammer_factory.NewBlock(miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{
+        nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+          Name: "result",
+          Value: miscValidatePruneProgrammer_factory.NewCallExpression(
+            miscValidatePruneProgrammer_factory.NewIdentifier("__validate"),
+            nil,
+            nil,
+            miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidatePruneProgrammer_factory.NewIdentifier("input")}),
+            shimast.NodeFlagsNone,
+          ),
+        }),
+        miscValidatePruneProgrammer_factory.NewIfStatement(
+          miscValidatePruneProgrammer_factory.NewIdentifier("result.success"),
+          miscValidatePruneProgrammer_factory.NewExpressionStatement(
+            miscValidatePruneProgrammer_factory.NewCallExpression(
+              miscValidatePruneProgrammer_factory.NewIdentifier("__prune"),
+              nil,
+              nil,
+              miscValidatePruneProgrammer_factory.NewNodeList([]*shimast.Node{miscValidatePruneProgrammer_factory.NewIdentifier("input")}),
+              shimast.NodeFlagsNone,
+            ),
+          ),
+          nil,
+        ),
+        miscValidatePruneProgrammer_factory.NewReturnStatement(miscValidatePruneProgrammer_factory.NewIdentifier("result")),
+      }), true),
+    ),
+  }
 }
 
 func (miscValidatePruneProgrammerNamespace) Write(props nativecontext.IProgrammerProps) *shimast.Node {
-	functor := nativehelpers.NewFunctionProgrammer(miscCloneProgrammer_method_text(props.Modulo))
-	result := MiscValidatePruneProgrammer.Decompose(MiscValidatePruneProgrammer_DecomposeProps{
-		Context: props.Context,
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Type:    props.Type,
-		Name:    props.Name,
-	})
-	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Result:  result,
-	})
+  functor := nativehelpers.NewFunctionProgrammer(miscCloneProgrammer_method_text(props.Modulo))
+  result := MiscValidatePruneProgrammer.Decompose(MiscValidatePruneProgrammer_DecomposeProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
 }

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

@@ -1,13 +1,13 @@
 package notations
 
 import (
-	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"
+  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"
 )
 
 type notationAssertGeneralProgrammerNamespace struct{}
@@ -17,90 +17,90 @@ var NotationAssertGeneralProgrammer = notationAssertGeneralProgrammerNamespace{}
 type NotationAssertGeneralProgrammer_IProps = NotationGeneralProgrammer_IProps
 
 type NotationAssertGeneralProgrammer_DecomposeProps struct {
-	Rename  NotationGeneralProgrammer_IRename
-	Context nativecontext.ITypiaContext
-	Functor *nativehelpers.FunctionProgrammer
-	Type    *shimchecker.Type
-	Name    *string
-	Init    *shimast.Node
+  Rename  NotationGeneralProgrammer_IRename
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
+  Init    *shimast.Node
 }
 
 var notationAssertGeneralProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (notationAssertGeneralProgrammerNamespace) Decompose(props NotationAssertGeneralProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-	assert := nativeprogrammers.AssertProgrammer.Decompose(nativeprogrammers.AssertProgrammer_DecomposeProps{
-		Context: props.Context,
-		Functor: props.Functor,
-		Config:  nativeprogrammers.AssertProgrammer_IConfig{Equals: false, Guard: false},
-		Type:    props.Type,
-		Name:    props.Name,
-		Init:    props.Init,
-	})
-	notation := NotationGeneralProgrammer.Decompose(NotationGeneralProgrammer_DecomposeProps{
-		Rename:    props.Rename,
-		Context:   props.Context,
-		Functor:   props.Functor,
-		Type:      props.Type,
-		Name:      props.Name,
-		Validated: true,
-	})
-	statements := append([]*shimast.Node{}, assert.Statements...)
-	statements = append(statements, notation.Statements...)
-	statements = append(statements,
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__assert", Value: assert.Arrow}),
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__notation", Value: notation.Arrow}),
-	)
-	return nativeinternal.FeatureProgrammer_IDecomposed{
-		Functions:  notationGeneralProgrammer_merge_functions(assert.Functions, notation.Functions),
-		Statements: statements,
-		Arrow: notationAssertGeneralProgrammer_factory.NewArrowFunction(
-			nil,
-			nil,
-			notationAssertGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-				nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
-				nativeprogrammers.Guardian.Parameter(struct {
-					Context nativecontext.ITypiaContext
-					Init    *shimast.Node
-				}{Context: props.Context, Init: props.Init}),
-			}),
-			notation.Arrow.AsArrowFunction().Type,
-			nil,
-			notationAssertGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			notationAssertGeneralProgrammer_factory.NewCallExpression(
-				notationAssertGeneralProgrammer_factory.NewIdentifier("__notation"),
-				nil,
-				nil,
-				notationAssertGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-					notationAssertGeneralProgrammer_factory.NewCallExpression(
-						notationAssertGeneralProgrammer_factory.NewIdentifier("__assert"),
-						nil,
-						nil,
-						notationAssertGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
-							notationAssertGeneralProgrammer_factory.NewIdentifier("input"),
-							nativeprogrammers.Guardian.Identifier(),
-						}),
-						shimast.NodeFlagsNone,
-					),
-				}),
-				shimast.NodeFlagsNone,
-			),
-		),
-	}
+  assert := nativeprogrammers.AssertProgrammer.Decompose(nativeprogrammers.AssertProgrammer_DecomposeProps{
+    Context: props.Context,
+    Functor: props.Functor,
+    Config:  nativeprogrammers.AssertProgrammer_IConfig{Equals: false, Guard: false},
+    Type:    props.Type,
+    Name:    props.Name,
+    Init:    props.Init,
+  })
+  notation := NotationGeneralProgrammer.Decompose(NotationGeneralProgrammer_DecomposeProps{
+    Rename:    props.Rename,
+    Context:   props.Context,
+    Functor:   props.Functor,
+    Type:      props.Type,
+    Name:      props.Name,
+    Validated: true,
+  })
+  statements := append([]*shimast.Node{}, assert.Statements...)
+  statements = append(statements, notation.Statements...)
+  statements = append(statements,
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__assert", Value: assert.Arrow}),
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__notation", Value: notation.Arrow}),
+  )
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  notationGeneralProgrammer_merge_functions(assert.Functions, notation.Functions),
+    Statements: statements,
+    Arrow: notationAssertGeneralProgrammer_factory.NewArrowFunction(
+      nil,
+      nil,
+      notationAssertGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+        nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
+        nativeprogrammers.Guardian.Parameter(struct {
+          Context nativecontext.ITypiaContext
+          Init    *shimast.Node
+        }{Context: props.Context, Init: props.Init}),
+      }),
+      notation.Arrow.AsArrowFunction().Type,
+      nil,
+      notationAssertGeneralProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      notationAssertGeneralProgrammer_factory.NewCallExpression(
+        notationAssertGeneralProgrammer_factory.NewIdentifier("__notation"),
+        nil,
+        nil,
+        notationAssertGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+          notationAssertGeneralProgrammer_factory.NewCallExpression(
+            notationAssertGeneralProgrammer_factory.NewIdentifier("__assert"),
+            nil,
+            nil,
+            notationAssertGeneralProgrammer_factory.NewNodeList([]*shimast.Node{
+              notationAssertGeneralProgrammer_factory.NewIdentifier("input"),
+              nativeprogrammers.Guardian.Identifier(),
+            }),
+            shimast.NodeFlagsNone,
+          ),
+        }),
+        shimast.NodeFlagsNone,
+      ),
+    ),
+  }
 }
 
 func (notationAssertGeneralProgrammerNamespace) Write(props NotationAssertGeneralProgrammer_IProps) *shimast.Node {
-	functor := nativehelpers.NewFunctionProgrammer(notationGeneralProgrammer_method_text(props.Modulo))
-	result := NotationAssertGeneralProgrammer.Decompose(NotationAssertGeneralProgrammer_DecomposeProps{
-		Rename:  props.Rename,
-		Context: props.Context,
-		Functor: functor,
-		Type:    props.Type,
-		Name:    props.Name,
-		Init:    props.Init,
-	})
-	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Result:  result,
-	})
+  functor := nativehelpers.NewFunctionProgrammer(notationGeneralProgrammer_method_text(props.Modulo))
+  result := NotationAssertGeneralProgrammer.Decompose(NotationAssertGeneralProgrammer_DecomposeProps{
+    Rename:  props.Rename,
+    Context: props.Context,
+    Functor: functor,
+    Type:    props.Type,
+    Name:    props.Name,
+    Init:    props.Init,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
 }