typia 13.0.0-dev.20260427-3 → 13.0.0-dev.20260430

package/native/core/programmers/ValidateProgrammer.go

@@ -0,0 +1,457 @@
+package programmers
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativechecker "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"
+	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"
+)
+
+type validateProgrammerNamespace struct{}
+
+var ValidateProgrammer = validateProgrammerNamespace{}
+
+type ValidateProgrammer_IConfig struct {
+	Equals         bool
+	StandardSchema bool
+}
+
+type ValidateProgrammer_IProps struct {
+	Context nativecontext.ITypiaContext
+	Modulo  *shimast.Node
+	Type    *nativechecker.Type
+	Name    *string
+	Init    *shimast.Node
+	Config  ValidateProgrammer_IConfig
+}
+
+type ValidateProgrammer_DecomposeProps struct {
+	Context nativecontext.ITypiaContext
+	Modulo  *shimast.Node
+	Functor *nativehelpers.FunctionProgrammer
+	Config  ValidateProgrammer_IConfig
+	Type    *nativechecker.Type
+	Name    *string
+}
+
+var validateProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (validateProgrammerNamespace) Decompose(props ValidateProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
+	is := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
+		Context: props.Context,
+		Functor: props.Functor,
+		Config:  IsProgrammer_IConfig{Equals: props.Config.Equals},
+		Type:    props.Type,
+		Name:    props.Name,
+	})
+	composed := nativeinternal.CheckerProgrammer.Compose(nativeinternal.CheckerProgrammer_ComposeProps{
+		Context: props.Context,
+		Functor: props.Functor,
+		Type:    props.Type,
+		Name:    props.Name,
+		Config: nativeinternal.CheckerProgrammer_IConfig{
+			Prefix:  "_v",
+			Path:    true,
+			Trace:   true,
+			Numeric: nativehelpers.OptionPredicator.Numeric(props.Context.Options),
+			Equals:  props.Config.Equals,
+			Atomist: validateProgrammer_atomist(props),
+			Combiner: validateProgrammer_combine(struct {
+				Config  ValidateProgrammer_IConfig
+				Context nativecontext.ITypiaContext
+				Functor *nativehelpers.FunctionProgrammer
+			}{Config: props.Config, Context: props.Context, Functor: props.Functor}),
+			Joiner:  validateProgrammer_joiner(props),
+			Success: validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+		},
+	})
+
+	typ := validateProgrammer_type_reference(props.Context, props.Type, props.Name)
+	arrow := validateProgrammer_factory.NewArrowFunction(
+		nil,
+		nil,
+		validateProgrammer_factory.NewNodeList([]*shimast.Node{
+			nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("any"), nil),
+		}),
+		validateProgrammer_import_type(props.Context, ImportProgrammer_TypeProps{
+			File:      "typia",
+			Name:      "IValidation",
+			Arguments: []*shimast.TypeNode{typ},
+		}),
+		nil,
+		validateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+		validateProgrammer_factory.NewBlock(validateProgrammer_factory.NewNodeList([]*shimast.Node{
+			validateProgrammer_factory.NewIfStatement(
+				validateProgrammer_equal(
+					validateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword),
+					validateProgrammer_factory.NewCallExpression(
+						validateProgrammer_factory.NewIdentifier("__is"),
+						nil,
+						nil,
+						validateProgrammer_factory.NewNodeList([]*shimast.Node{validateProgrammer_factory.NewIdentifier("input")}),
+						shimast.NodeFlagsNone,
+					),
+				),
+				validateProgrammer_factory.NewBlock(validateProgrammer_factory.NewNodeList([]*shimast.Node{
+					validateProgrammer_factory.NewExpressionStatement(validateProgrammer_factory.NewBinaryExpression(nil, validateProgrammer_factory.NewIdentifier("errors"), nil, validateProgrammer_factory.NewToken(shimast.KindEqualsToken), validateProgrammer_factory.NewArrayLiteralExpression(validateProgrammer_factory.NewNodeList(nil), false))),
+					validateProgrammer_factory.NewExpressionStatement(validateProgrammer_factory.NewBinaryExpression(
+						nil,
+						validateProgrammer_factory.NewIdentifier("_report"),
+						nil,
+						validateProgrammer_factory.NewToken(shimast.KindEqualsToken),
+						validateProgrammer_factory.NewCallExpression(
+							validateProgrammer_factory.NewAsExpression(validateProgrammer_internal(props.Context, "validateReport"), nativefactories.TypeFactory.Keyword("any")),
+							nil,
+							validateProgrammer_factory.NewNodeList(nil),
+							validateProgrammer_factory.NewNodeList([]*shimast.Node{validateProgrammer_factory.NewIdentifier("errors")}),
+							shimast.NodeFlagsNone,
+						),
+					)),
+					validateProgrammer_factory.NewExpressionStatement(validateProgrammer_factory.NewCallExpression(
+						validateProgrammer_factory.NewArrowFunction(nil, nil, validateProgrammer_factory.NewNodeList(composed.Parameters), nil, nil, validateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken), composed.Body),
+						nil,
+						nil,
+						validateProgrammer_factory.NewNodeList([]*shimast.Node{
+							validateProgrammer_factory.NewIdentifier("input"),
+							validateProgrammer_factory.NewStringLiteral("$input", shimast.TokenFlagsNone),
+							validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+						}),
+						shimast.NodeFlagsNone,
+					)),
+					nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+						Name: "success",
+						Value: validateProgrammer_equal(
+							nativefactories.ExpressionFactory.Number(0),
+							validateProgrammer_factory.NewIdentifier("errors.length"),
+						),
+					}),
+					validateProgrammer_factory.NewReturnStatement(validateProgrammer_factory.NewAsExpression(validateProgrammer_create_output(), nativefactories.TypeFactory.Keyword("any"))),
+				}), true),
+				nil,
+			),
+			validateProgrammer_factory.NewReturnStatement(validateProgrammer_factory.NewAsExpression(
+				validateProgrammer_factory.NewObjectLiteralExpression(validateProgrammer_factory.NewNodeList([]*shimast.Node{
+					validateProgrammer_property("success", validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword)),
+					validateProgrammer_property("data", validateProgrammer_factory.NewIdentifier("input")),
+				}), true),
+				nativefactories.TypeFactory.Keyword("any"),
+			)),
+		}), true),
+	)
+
+	functions := map[string]*shimast.Node{}
+	for key, value := range is.Functions {
+		functions[key] = value
+	}
+	for key, value := range composed.Functions {
+		functions[key] = value
+	}
+	statements := []*shimast.Node{}
+	statements = append(statements, is.Statements...)
+	statements = append(statements, composed.Statements...)
+	statements = append(statements,
+		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__is", Value: is.Arrow}),
+		nativefactories.StatementFactory.Mut(nativefactories.StatementFactory_MutProps{Name: "errors"}),
+		nativefactories.StatementFactory.Mut(nativefactories.StatementFactory_MutProps{Name: "_report"}),
+	)
+	return nativeinternal.FeatureProgrammer_IDecomposed{
+		Functions:  functions,
+		Statements: statements,
+		Arrow:      arrow,
+	}
+}
+
+func (validateProgrammerNamespace) Write(props ValidateProgrammer_IProps) *shimast.Node {
+	method := ""
+	if props.Modulo != nil {
+		method = props.Modulo.Text()
+	}
+	functor := nativehelpers.NewFunctionProgrammer(method)
+	result := ValidateProgrammer.Decompose(ValidateProgrammer_DecomposeProps{
+		Config:  props.Config,
+		Context: props.Context,
+		Modulo:  props.Modulo,
+		Functor: functor,
+		Type:    props.Type,
+		Name:    props.Name,
+	})
+	var wrapper func(arrow *shimast.Node) *shimast.Node
+	if props.Config.StandardSchema {
+		wrapper = func(arrow *shimast.Node) *shimast.Node {
+			return validateProgrammer_factory.NewCallExpression(validateProgrammer_internal(props.Context, "createStandardSchema"), nil, nil, validateProgrammer_factory.NewNodeList([]*shimast.Node{arrow}), shimast.NodeFlagsNone)
+		}
+	}
+	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+		Modulo:        props.Modulo,
+		Functor:       functor,
+		Result:        result,
+		ReturnWrapper: wrapper,
+	})
+}
+
+func validateProgrammer_atomist(props ValidateProgrammer_DecomposeProps) func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
+	return func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
+		expressions := []*shimast.Node{}
+		if next.Entry.Expression != nil {
+			expressions = append(expressions, next.Entry.Expression)
+		}
+		if len(next.Entry.Conditions) != 0 {
+			exceptionable := validateProgrammer_exceptionable(next.Explore)
+			path := validateProgrammer_path(next.Explore)
+			if len(next.Entry.Conditions) == 1 {
+				for _, cond := range next.Entry.Conditions[0] {
+					expressions = append(expressions, validateProgrammer_or(
+						cond.Expression,
+						validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{Exceptionable: exceptionable, Path: path, Expected: cond.Expected, Value: next.Input}),
+					))
+				}
+			} else {
+				rows := []*shimast.Node{}
+				for _, set := range next.Entry.Conditions {
+					cols := []*shimast.Node{}
+					for _, s := range set {
+						cols = append(cols, s.Expression)
+					}
+					rows = append(rows, validateProgrammer_reduce(cols, shimast.KindAmpersandAmpersandToken, validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword)))
+				}
+				expressions = append(expressions, validateProgrammer_or(
+					validateProgrammer_reduce(rows, shimast.KindBarBarToken, validateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword)),
+					validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{Exceptionable: exceptionable, Path: path, Expected: next.Entry.Expected, Value: next.Input}),
+				))
+			}
+		}
+		return validateProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword))
+	}
+}
+
+func validateProgrammer_combine(props struct {
+	Config  ValidateProgrammer_IConfig
+	Context nativecontext.ITypiaContext
+	Functor *nativehelpers.FunctionProgrammer
+}) nativeinternal.CheckerProgrammer_IConfig_Combiner {
+	return func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
+		if next.Explore.Tracable == false {
+			options := &IsProgrammer_CONFIG_IOptions{
+				Numeric: validateProgrammer_bool_ptr(true),
+				Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
+					return validateProgrammer_validate_object(validateProgrammer_validateObjectProps{Context: props.Context, Functor: props.Functor, Config: props.Config, Entries: v.Entries, Input: v.Input})
+				},
+			}
+			return IsProgrammer.Configure(struct {
+				Options *IsProgrammer_CONFIG_IOptions
+				Context nativecontext.ITypiaContext
+				Functor *nativehelpers.FunctionProgrammer
+			}{Options: options, Context: props.Context, Functor: props.Functor}).Combiner(next)
+		}
+		path := validateProgrammer_path(next.Explore)
+		exceptionable := validateProgrammer_exceptionable(next.Explore)
+		if next.Logic == "and" {
+			expressions := []*shimast.Node{}
+			for _, binary := range next.Binaries {
+				if binary.Combined {
+					expressions = append(expressions, binary.Expression)
+				} else {
+					expressions = append(expressions, validateProgrammer_or(binary.Expression, validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{Exceptionable: exceptionable, Path: path, Expected: next.Expected, Value: next.Input})))
+				}
+			}
+			return validateProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword))
+		}
+		expressions := []*shimast.Node{}
+		for _, binary := range next.Binaries {
+			expressions = append(expressions, binary.Expression)
+		}
+		return validateProgrammer_or(
+			validateProgrammer_reduce(expressions, shimast.KindBarBarToken, validateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword)),
+			validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{Exceptionable: exceptionable, Path: path, Expected: next.Expected, Value: next.Input}),
+		)
+	}
+}
+
+type validateProgrammer_validateObjectProps struct {
+	Config  ValidateProgrammer_IConfig
+	Context nativecontext.ITypiaContext
+	Functor *nativehelpers.FunctionProgrammer
+	Entries []nativehelpers.IExpressionEntry
+	Input   *shimast.Expression
+}
+
+func validateProgrammer_validate_object(props validateProgrammer_validateObjectProps) *shimast.Node {
+	return nativeiterate.Check_object(nativeiterate.Check_objectProps{
+		Config: nativeiterate.Check_object_IConfig{
+			Equals:    props.Config.Equals,
+			Undefined: true,
+			Assert:    false,
+			Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
+				return validateProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b)
+			},
+			Positive: validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+			Superfluous: func(input *shimast.Expression, description *shimast.Expression) *shimast.Node {
+				return validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{
+					Path: validateProgrammer_binary(
+						validateProgrammer_factory.NewIdentifier("_path"),
+						shimast.KindPlusToken,
+						validateProgrammer_factory.NewCallExpression(validateProgrammer_internal(props.Context, "accessExpressionAsString"), nil, nil, validateProgrammer_factory.NewNodeList([]*shimast.Node{validateProgrammer_factory.NewIdentifier("key")}), shimast.NodeFlagsNone),
+					),
+					Expected:    "undefined",
+					Value:       input,
+					Description: description,
+				})
+			},
+			Halt: func(expr *shimast.Expression) *shimast.Node {
+				return validateProgrammer_or(validateProgrammer_equal(validateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword), validateProgrammer_factory.NewIdentifier("_exceptionable")), expr)
+			},
+		},
+		Context: props.Context,
+		Entries: props.Entries,
+		Input:   props.Input,
+	})
+}
+
+func validateProgrammer_joiner(props ValidateProgrammer_DecomposeProps) nativeinternal.CheckerProgrammer_IConfig_IJoiner {
+	return nativeinternal.CheckerProgrammer_IConfig_IJoiner{
+		Object: func(v nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
+			return validateProgrammer_validate_object(validateProgrammer_validateObjectProps{Context: props.Context, Functor: props.Functor, Config: props.Config, Entries: v.Entries, Input: v.Input})
+		},
+		Array: func(v nativeinternal.CheckerProgrammer_JoinerArrayProps) *shimast.Node {
+			return nativeiterate.Check_everything(validateProgrammer_factory.NewCallExpression(nativefactories.IdentifierFactory.Access(v.Input, "map"), nil, nil, validateProgrammer_factory.NewNodeList([]*shimast.Node{v.Arrow}), shimast.NodeFlagsNone))
+		},
+		Failure: func(next nativeinternal.CheckerProgrammer_JoinerFailureProps) *shimast.Node {
+			explore := nativeinternal.FeatureProgrammer_IExplore{}
+			if next.Explore != nil {
+				explore = *next.Explore
+			}
+			return validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{Exceptionable: validateProgrammer_exceptionable(explore), Path: validateProgrammer_path(explore), Expected: next.Expected, Value: next.Input})
+		},
+		Tuple: func(binaries []*shimast.Node) *shimast.Node {
+			return nativeiterate.Check_everything(validateProgrammer_factory.NewArrayLiteralExpression(validateProgrammer_factory.NewNodeList(binaries), true))
+		},
+	}
+}
+
+func validateProgrammer_create_output() *shimast.Node {
+	return validateProgrammer_factory.NewConditionalExpression(
+		validateProgrammer_factory.NewIdentifier("success"),
+		nil,
+		validateProgrammer_factory.NewObjectLiteralExpression(validateProgrammer_factory.NewNodeList([]*shimast.Node{
+			validateProgrammer_shorthand("success"),
+			validateProgrammer_property("data", validateProgrammer_factory.NewIdentifier("input")),
+		}), true),
+		nil,
+		validateProgrammer_factory.NewObjectLiteralExpression(validateProgrammer_factory.NewNodeList([]*shimast.Node{
+			validateProgrammer_shorthand("success"),
+			validateProgrammer_shorthand("errors"),
+			validateProgrammer_property("data", validateProgrammer_factory.NewIdentifier("input")),
+		}), true),
+	)
+}
+
+type validateProgrammer_createReportCallProps struct {
+	Exceptionable *shimast.Expression
+	Path          *shimast.Expression
+	Expected      string
+	Value         *shimast.Expression
+	Description   *shimast.Expression
+}
+
+func validateProgrammer_create_report_call(props validateProgrammer_createReportCallProps) *shimast.Node {
+	exceptionable := props.Exceptionable
+	if exceptionable == nil {
+		exceptionable = validateProgrammer_factory.NewIdentifier("_exceptionable")
+	}
+	properties := []*shimast.Node{
+		validateProgrammer_property("path", props.Path),
+		validateProgrammer_property("expected", validateProgrammer_factory.NewStringLiteral(props.Expected, shimast.TokenFlagsNone)),
+		validateProgrammer_property("value", props.Value),
+	}
+	if props.Description != nil {
+		properties = append(properties, validateProgrammer_property("description", props.Description))
+	}
+	return validateProgrammer_factory.NewCallExpression(
+		validateProgrammer_factory.NewIdentifier("_report"),
+		nil,
+		nil,
+		validateProgrammer_factory.NewNodeList([]*shimast.Node{
+			exceptionable,
+			validateProgrammer_factory.NewObjectLiteralExpression(validateProgrammer_factory.NewNodeList(properties), true),
+		}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func validateProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind, initial *shimast.Expression) *shimast.Node {
+	if len(expressions) == 0 {
+		return initial
+	}
+	output := expressions[0]
+	for _, expr := range expressions[1:] {
+		output = validateProgrammer_binary(output, operator, expr)
+	}
+	return output
+}
+
+func validateProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression) *shimast.Node {
+	return validateProgrammer_factory.NewBinaryExpression(nil, left, nil, validateProgrammer_factory.NewToken(operator), right)
+}
+
+func validateProgrammer_equal(left *shimast.Expression, right *shimast.Expression) *shimast.Node {
+	return validateProgrammer_binary(left, shimast.KindEqualsEqualsEqualsToken, right)
+}
+
+func validateProgrammer_or(left *shimast.Expression, right *shimast.Expression) *shimast.Node {
+	return validateProgrammer_binary(left, shimast.KindBarBarToken, right)
+}
+
+func validateProgrammer_property(name string, value *shimast.Expression) *shimast.Node {
+	return validateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier(name), nil, nil, value)
+}
+
+func validateProgrammer_shorthand(name string) *shimast.Node {
+	return validateProgrammer_factory.NewShorthandPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier(name), nil, nil, nil, nil)
+}
+
+func validateProgrammer_exceptionable(explore nativeinternal.FeatureProgrammer_IExplore) *shimast.Node {
+	if explore.From == "top" || explore.Source == "top" {
+		return validateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword)
+	}
+	return validateProgrammer_factory.NewIdentifier("_exceptionable")
+}
+
+func validateProgrammer_path(explore nativeinternal.FeatureProgrammer_IExplore) *shimast.Node {
+	if explore.Postfix != "" {
+		return validateProgrammer_factory.NewIdentifier("_path + " + explore.Postfix)
+	}
+	return validateProgrammer_factory.NewIdentifier("_path")
+}
+
+func validateProgrammer_type_reference(context nativecontext.ITypiaContext, typ *nativechecker.Type, name *string) *shimast.Node {
+	if name != nil {
+		return validateProgrammer_factory.NewTypeReferenceNode(validateProgrammer_factory.NewIdentifier(*name), nil)
+	}
+	return validateProgrammer_factory.NewTypeReferenceNode(validateProgrammer_factory.NewIdentifier(nativefactories.TypeFactory.GetFullName(nativefactories.TypeFactory_GetFullNameProps{Checker: context.Checker, Type: typ})), nil)
+}
+
+func validateProgrammer_import_type(context nativecontext.ITypiaContext, props ImportProgrammer_TypeProps) *shimast.Node {
+	if importer, ok := context.Importer.(interface {
+		Type(ImportProgrammer_TypeProps) *shimast.Node
+	}); ok {
+		return importer.Type(props)
+	}
+	if str, ok := props.Name.(string); ok {
+		return validateProgrammer_factory.NewTypeReferenceNode(validateProgrammer_factory.NewIdentifier(str), nil)
+	}
+	return props.Name.(*shimast.Node)
+}
+
+func validateProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
+	if importer, ok := context.Importer.(interface{ Internal(string) *shimast.Node }); ok {
+		return importer.Internal(name)
+	}
+	return validateProgrammer_factory.NewIdentifier(name)
+}
+
+func validateProgrammer_bool_ptr(value bool) *bool {
+	return &value
+}

package/native/core/programmers/functional/FunctionalAssertFunctionProgrammer.go

@@ -0,0 +1,169 @@
+package functional
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	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"
+)
+
+type functionalAssertFunctionProgrammerNamespace struct{}
+
+var FunctionalAssertFunctionProgrammer = functionalAssertFunctionProgrammerNamespace{}
+
+type FunctionalAssertFunctionProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalAssertFunctionProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalAssertFunctionProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionalAssertFunctionProgrammer_ErrorFactoryWrapperOutput struct {
+	Name     string
+	Variable *shimast.Node
+}
+
+var functionalAssertProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (functionalAssertFunctionProgrammerNamespace) Write(props FunctionalAssertFunctionProgrammer_IProps) *shimast.Node {
+	wrapper := FunctionalAssertFunctionProgrammer.ErrorFactoryWrapper(struct {
+		Context    nativecontext.ITypiaContext
+		Parameters []*shimast.Node
+		Init       *shimast.Node
+	}{
+		Context:    props.Context,
+		Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
+		Init:       props.Init,
+	})
+	p := FunctionalAssertParametersProgrammer.Decompose(FunctionalAssertParametersProgrammer_IDecomposeProps{
+		Context:    props.Context,
+		Modulo:     props.Modulo,
+		Config:     FunctionalAssertParametersProgrammer_IConfig{Equals: props.Config.Equals},
+		Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
+		Wrapper:    wrapper.Name,
+	})
+	r := FunctionAssertReturnProgrammer.Decompose(FunctionAssertReturnProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      FunctionAssertReturnProgrammer_IConfig{Equals: props.Config.Equals},
+		Expression:  props.Expression,
+		Declaration: props.Declaration,
+		Wrapper:     wrapper.Name,
+	})
+	statements := []*shimast.Node{wrapper.Variable}
+	statements = append(statements, p.Functions...)
+	statements = append(statements, r.Functions...)
+	body := []*shimast.Node{}
+	for _, exp := range p.Expressions {
+		body = append(body, functionalAssertProgrammer_factory.NewExpressionStatement(exp))
+	}
+	body = append(body, functionalAssertProgrammer_factory.NewReturnStatement(r.Value))
+	statements = append(statements, functionalAssertProgrammer_factory.NewReturnStatement(
+		functionalAssertProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(r.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			functionalAssertProgrammer_returnType(props.Declaration),
+			nil,
+			functionalAssertProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(body), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalAssertFunctionProgrammerNamespace) ErrorFactoryWrapper(props struct {
+	Context    nativecontext.ITypiaContext
+	Parameters []*shimast.Node
+	Init       *shimast.Node
+}) FunctionalAssertFunctionProgrammer_ErrorFactoryWrapperOutput {
+	names := make([]string, 0, len(props.Parameters))
+	for _, p := range props.Parameters {
+		names = append(names, functionalIsProgrammer_parameterName(p))
+	}
+	name := functionalIsProgrammer_escapeDuplicate(names, "errorFactoryWrapper")
+	init := props.Init
+	if init == nil {
+		init = functionalAssertProgrammer_internal(props.Context, "functionalTypeGuardErrorFactory")
+	}
+	return FunctionalAssertFunctionProgrammer_ErrorFactoryWrapperOutput{
+		Name: name,
+		Variable: nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+			Name:  name,
+			Type:  nativeprogrammers.Guardian.Type(props.Context),
+			Value: init,
+		}),
+	}
+}
+
+func (functionalAssertFunctionProgrammerNamespace) HookPath(props struct {
+	Wrapper  string
+	Replacer string
+}) *shimast.Node {
+	path := nativefactories.IdentifierFactory.Access(functionalAssertProgrammer_factory.NewIdentifier("p"), "path")
+	return functionalAssertProgrammer_factory.NewArrowFunction(
+		nil,
+		nil,
+		functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{
+			nativefactories.IdentifierFactory.Parameter("p", nil, nil),
+		}),
+		nil,
+		nil,
+		functionalAssertProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+		functionalAssertProgrammer_factory.NewCallExpression(
+			functionalAssertProgrammer_factory.NewIdentifier(props.Wrapper),
+			nil,
+			nil,
+			functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{
+				functionalAssertProgrammer_factory.NewObjectLiteralExpression(functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{
+					functionalAssertProgrammer_factory.NewSpreadAssignment(functionalAssertProgrammer_factory.NewIdentifier("p")),
+					functionalAssertProgrammer_factory.NewPropertyAssignment(
+						nil,
+						nativefactories.IdentifierFactory.Identifier("path"),
+						nil,
+						nil,
+						functionalAssertProgrammer_factory.NewConditionalExpression(
+							path,
+							nil,
+							functionalAssertProgrammer_factory.NewCallExpression(
+								nativefactories.IdentifierFactory.Access(path, "replace"),
+								nil,
+								nil,
+								functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{
+									functionalAssertProgrammer_factory.NewStringLiteral("$input", shimast.TokenFlagsNone),
+									functionalAssertProgrammer_factory.NewStringLiteral(props.Replacer, shimast.TokenFlagsNone),
+								}),
+								shimast.NodeFlagsNone,
+							),
+							nil,
+							functionalAssertProgrammer_factory.NewIdentifier("undefined"),
+						),
+					),
+				}), false),
+			}),
+			shimast.NodeFlagsNone,
+		),
+	)
+}
+
+func functionalAssertProgrammer_returnType(declaration *shimast.Node) *shimast.Node {
+	if declaration == nil || declaration.FunctionLikeData() == nil {
+		return nil
+	}
+	return declaration.FunctionLikeData().Type
+}
+
+func functionalAssertProgrammer_internal(context nativecontext.ITypiaContext, name string) *shimast.Node {
+	if importer, ok := context.Importer.(interface{ Internal(string) *shimast.Node }); ok {
+		return importer.Internal(name)
+	}
+	return functionalAssertProgrammer_factory.NewIdentifier(name)
+}