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

package/native/transform/features/json/JsonIsParseTransformer.go

@@ -0,0 +1,22 @@
+package json
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonIsParseTransformerNamespace struct{}
+
+var JsonIsParseTransformer = jsonIsParseTransformerNamespace{}
+
+func (jsonIsParseTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
+	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+		ITransformProps: props,
+		Method:          "json.isParse",
+		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+			return nativejsonprogrammers.JsonIsParseProgrammer.Write(x)
+		},
+	})
+}

package/native/transform/features/json/JsonIsStringifyTransformer.go

@@ -0,0 +1,22 @@
+package json
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonIsStringifyTransformerNamespace struct{}
+
+var JsonIsStringifyTransformer = jsonIsStringifyTransformerNamespace{}
+
+func (jsonIsStringifyTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
+	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+		ITransformProps: props,
+		Method:          "json.isStringify",
+		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+			return nativejsonprogrammers.JsonIsStringifyProgrammer.Write(x)
+		},
+	})
+}

package/native/transform/features/json/JsonSchemaTransformer.go

@@ -0,0 +1,176 @@
+package json
+
+import (
+	"fmt"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonSchemaTransformerNamespace struct{}
+
+var JsonSchemaTransformer = jsonSchemaTransformerNamespace{}
+
+func (jsonSchemaTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+			Code:    "typia.json.schema",
+			Message: "no generic argument.",
+		}))
+	}
+
+	top := props.Expression.TypeArguments.Nodes[0]
+	if top == nil {
+		return props.Expression.AsNode()
+	}
+
+	typ := props.Context.Checker.GetTypeFromTypeNode(top)
+	if typ != nil && typ.IsTypeParameter() {
+		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+			Code:    "typia.json.schema",
+			Message: "non-specified generic argument.",
+		}))
+	}
+
+	var versionNode *shimast.Node
+	if len(props.Expression.TypeArguments.Nodes) > 1 {
+		versionNode = props.Expression.TypeArguments.Nodes[1]
+	}
+	version := jsonTransformer_getParameter(jsonTransformer_getParameterProps{
+		Checker: props.Context.Checker,
+		Code:    "typia.json.schema",
+		Name:    "Version",
+		Is: func(str string) bool {
+			return str == "3.0" || str == "3.1"
+		},
+		Default: func() string {
+			return "3.1"
+		},
+	})(versionNode)
+
+	analyze := func(validate bool) *schemametadata.MetadataSchema {
+		var validator nativefactories.MetadataFactory_Validator
+		if validate {
+			validator = jsonTransformer_schemasValidator
+		}
+		result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+			Checker:     props.Context.Checker,
+			Transformer: props.Context.Transformer,
+			Options: nativefactories.MetadataFactory_IOptions{
+				Absorb:   validate,
+				Constant: true,
+				Escape:   true,
+				Validate: validator,
+			},
+			Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
+				Replace: schemametadata.MetadataCollection_replace,
+			}),
+			Type: typ,
+		})
+		if result.Success == false {
+			panic(nativetransform.TransformerError_from(struct {
+				Code   string
+				Errors []nativetransform.TransformerError_MetadataFactory_IError
+			}{
+				Code:   "typia.json.schema",
+				Errors: jsonTransformer_errors(result.Errors),
+			}))
+		}
+		return result.Data
+	}
+	analyze(true)
+
+	return nativejsonprogrammers.JsonSchemaProgrammer.Write(nativejsonprogrammers.JsonSchemaProgrammer_IWriteProps{
+		Context:  props.Context,
+		Version:  version,
+		Metadata: analyze(false),
+	})
+}
+
+type jsonTransformer_getParameterProps struct {
+	Checker *shimchecker.Checker
+	Code    string
+	Name    string
+	Is      func(value string) bool
+	Default func() string
+}
+
+func jsonTransformer_getParameter(props jsonTransformer_getParameterProps) func(node *shimast.Node) string {
+	return func(node *shimast.Node) string {
+		if node == nil {
+			return props.Default()
+		}
+		typ := props.Checker.GetTypeFromTypeNode(node)
+		if typ == nil || (typ.Flags()&shimchecker.TypeFlagsLiteral) == 0 {
+			panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+				Code:    props.Code,
+				Message: fmt.Sprintf("generic argument \"%s\" must be constant.", props.Name),
+			}))
+		}
+
+		value := ""
+		if typ.Flags()&shimchecker.TypeFlagsBooleanLiteral != 0 {
+			value = props.Checker.TypeToString(typ)
+		} else {
+			if str, ok := typ.AsLiteralType().Value().(string); ok {
+				value = str
+			}
+		}
+		if value == "" || props.Is(value) == false {
+			panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+				Code:    props.Code,
+				Message: fmt.Sprintf("invalid value on generic argument \"%s\".", props.Name),
+			}))
+		}
+		return value
+	}
+}
+
+func jsonTransformer_schemasValidator(props struct {
+	Metadata *schemametadata.MetadataSchema
+	Explore  nativefactories.MetadataFactory_IExplore
+	Top      *schemametadata.MetadataSchema
+}) []string {
+	return nativejsonprogrammers.JsonSchemasProgrammer.Validate(struct {
+		Metadata *schemametadata.MetadataSchema
+		Explore  nativefactories.MetadataFactory_IExplore
+	}{
+		Metadata: props.Metadata,
+		Explore:  props.Explore,
+	})
+}
+
+func jsonTransformer_applicationValidator(props struct {
+	Metadata *schemametadata.MetadataSchema
+	Explore  nativefactories.MetadataFactory_IExplore
+	Top      *schemametadata.MetadataSchema
+}) []string {
+	return nativejsonprogrammers.JsonApplicationProgrammer.Validate(struct {
+		Metadata *schemametadata.MetadataSchema
+		Explore  nativefactories.MetadataFactory_IExplore
+	}{
+		Metadata: props.Metadata,
+		Explore:  props.Explore,
+	})
+}
+
+func jsonTransformer_errors(errors []nativefactories.MetadataFactory_IError) []nativetransform.TransformerError_MetadataFactory_IError {
+	output := make([]nativetransform.TransformerError_MetadataFactory_IError, 0, len(errors))
+	for _, err := range errors {
+		output = append(output, nativetransform.TransformerError_MetadataFactory_IError{
+			Name: err.Name,
+			Explore: nativetransform.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
+}

package/native/transform/features/json/JsonSchemasTransformer.go

@@ -0,0 +1,110 @@
+package json
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonSchemasTransformerNamespace struct{}
+
+var JsonSchemasTransformer = jsonSchemasTransformerNamespace{}
+
+func (jsonSchemasTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+	if props.Expression == nil || props.Expression.TypeArguments == nil || len(props.Expression.TypeArguments.Nodes) == 0 {
+		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+			Code:    "typia.json.schemas",
+			Message: "no generic argument.",
+		}))
+	}
+
+	top := props.Expression.TypeArguments.Nodes[0]
+	if top == nil || top.Kind != shimast.KindTupleType {
+		return props.Expression.AsNode()
+	}
+	elements := top.AsTupleTypeNode().Elements
+	if elements == nil {
+		return props.Expression.AsNode()
+	}
+
+	types := make([]*shimchecker.Type, 0, len(elements.Nodes))
+	for _, child := range elements.Nodes {
+		if child == nil {
+			return props.Expression.AsNode()
+		}
+		typ := props.Context.Checker.GetTypeFromTypeNode(child)
+		if typ != nil && typ.IsTypeParameter() {
+			panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
+				Code:    "typia.json.schemas",
+				Message: "non-specified generic argument(s).",
+			}))
+		}
+		types = append(types, typ)
+	}
+
+	var versionNode *shimast.Node
+	if len(props.Expression.TypeArguments.Nodes) > 1 {
+		versionNode = props.Expression.TypeArguments.Nodes[1]
+	}
+	version := jsonTransformer_getParameter(jsonTransformer_getParameterProps{
+		Checker: props.Context.Checker,
+		Code:    "typia.json.schemas",
+		Name:    "Version",
+		Is: func(str string) bool {
+			return str == "3.0" || str == "3.1"
+		},
+		Default: func() string {
+			return "3.1"
+		},
+	})(versionNode)
+
+	analyze := func(validate bool) []*schemametadata.MetadataSchema {
+		metadatas := []*schemametadata.MetadataSchema{}
+		errors := []nativefactories.MetadataFactory_IError{}
+		var validator nativefactories.MetadataFactory_Validator
+		if validate {
+			validator = jsonTransformer_schemasValidator
+		}
+		for _, typ := range types {
+			result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+				Checker:     props.Context.Checker,
+				Transformer: props.Context.Transformer,
+				Options: nativefactories.MetadataFactory_IOptions{
+					Absorb:   validate,
+					Constant: true,
+					Escape:   true,
+					Validate: validator,
+				},
+				Components: schemametadata.NewMetadataCollection(&schemametadata.MetadataCollection_IOptions{
+					Replace: schemametadata.MetadataCollection_replace,
+				}),
+				Type: typ,
+			})
+			if result.Success == false {
+				errors = append(errors, result.Errors...)
+			} else {
+				metadatas = append(metadatas, result.Data)
+			}
+		}
+		if len(errors) != 0 {
+			panic(nativetransform.TransformerError_from(struct {
+				Code   string
+				Errors []nativetransform.TransformerError_MetadataFactory_IError
+			}{
+				Code:   "typia.json.schemas",
+				Errors: jsonTransformer_errors(errors),
+			}))
+		}
+		return metadatas
+	}
+	analyze(true)
+
+	return nativejsonprogrammers.JsonSchemasProgrammer.Write(nativejsonprogrammers.JsonSchemasProgrammer_IWriteProps{
+		Context:   props.Context,
+		Version:   version,
+		Metadatas: analyze(false),
+	})
+}

package/native/transform/features/json/JsonStringifyTransformer.go

@@ -0,0 +1,22 @@
+package json
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonStringifyTransformerNamespace struct{}
+
+var JsonStringifyTransformer = jsonStringifyTransformerNamespace{}
+
+func (jsonStringifyTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
+	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+		ITransformProps: props,
+		Method:          "json.stringify",
+		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+			return nativejsonprogrammers.JsonStringifyProgrammer.Write(x)
+		},
+	})
+}

package/native/transform/features/json/JsonValidateParseTransformer.go

@@ -0,0 +1,22 @@
+package json
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonValidateParseTransformerNamespace struct{}
+
+var JsonValidateParseTransformer = jsonValidateParseTransformerNamespace{}
+
+func (jsonValidateParseTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
+	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+		ITransformProps: props,
+		Method:          "json.validateParse",
+		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+			return nativejsonprogrammers.JsonValidateParseProgrammer.Write(x)
+		},
+	})
+}

package/native/transform/features/json/JsonValidateStringifyTransformer.go

@@ -0,0 +1,22 @@
+package json
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativejsonprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/json"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type jsonValidateStringifyTransformerNamespace struct{}
+
+var JsonValidateStringifyTransformer = jsonValidateStringifyTransformerNamespace{}
+
+func (jsonValidateStringifyTransformerNamespace) Transform(props nativeinternal.ITransformProps) *shimast.Node {
+	return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+		ITransformProps: props,
+		Method:          "json.validateStringify",
+		Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+			return nativejsonprogrammers.JsonValidateStringifyProgrammer.Write(x)
+		},
+	})
+}

package/native/transform/features/llm/LlmApplicationTransformer.go

@@ -0,0 +1,54 @@
+package llm
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type llmApplicationTransformerNamespace struct{}
+
+var LlmApplicationTransformer = llmApplicationTransformerNamespace{}
+
+func (llmApplicationTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.application")
+	if ok == false {
+		return props.Expression.AsNode()
+	}
+	config := llmTransformer_config(props, "application")
+	analyze := func(validate bool) *schemametadata.MetadataSchema {
+		return llmTransformer_analyze(llmTransformer_analyzeProps{
+			Context:    props.Context,
+			Type:       typ,
+			Code:       "typia.llm.application",
+			Absorb:     validate,
+			Functional: true,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				if validate == false {
+					return nil
+				}
+				return nativellmprogrammers.LlmApplicationProgrammer.Validate(struct {
+					Config   map[string]any
+					Metadata *schemametadata.MetadataSchema
+					Explore  nativefactories.MetadataFactory_IExplore
+					Top      *schemametadata.MetadataSchema
+				}{Config: config, Metadata: next.Metadata, Explore: next.Explore, Top: next.Top})
+			},
+		})
+	}
+	analyze(true)
+	return nativellmprogrammers.LlmApplicationProgrammer.Write(nativellmprogrammers.LlmApplicationProgrammer_IWriteProps{
+		Context:        props.Context,
+		Modulo:         props.Modulo,
+		Metadata:       analyze(false),
+		Name:           llmTransformer_type_name(top),
+		Config:         config,
+		ConfigArgument: llmTransformer_argument(props, 0),
+	})
+}

package/native/transform/features/llm/LlmCoerceTransformer.go

@@ -0,0 +1,61 @@
+package llm
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type llmCoerceTransformerNamespace struct{}
+
+var LlmCoerceTransformer = llmCoerceTransformerNamespace{}
+
+func (llmCoerceTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+	llmTransformer_require_argument(props, "typia.llm.coerce", 0, "no input value.")
+	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.coerce")
+	if ok == false {
+		return props.Expression.AsNode()
+	}
+	config := llmTransformer_config(props, "coerce")
+	if typ != nil && typ.IsTypeParameter() {
+		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.coerce", Message: "non-specified generic argument."}))
+	}
+	analyze := func(validate bool) *schemametadata.MetadataSchema {
+		return llmTransformer_analyze(llmTransformer_analyzeProps{
+			Context: props.Context,
+			Type:    typ,
+			Code:    "typia.llm.coerce",
+			Absorb:  validate,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				if validate == false {
+					return nil
+				}
+				return nativellmprogrammers.LlmCoerceProgrammer.Validate(struct {
+					Config   map[string]any
+					Metadata *schemametadata.MetadataSchema
+					Explore  nativefactories.MetadataFactory_IExplore
+				}{Config: config, Metadata: next.Metadata, Explore: next.Explore})
+			},
+		})
+	}
+	analyze(true)
+	return llmTransformer_factory.NewCallExpression(
+		nativellmprogrammers.LlmCoerceProgrammer.Write(nativellmprogrammers.LlmCoerceProgrammer_IWriteProps{
+			Context:  props.Context,
+			Modulo:   props.Modulo,
+			Metadata: analyze(false),
+			Name:     llmTransformer_type_name(top),
+			Config:   config,
+		}),
+		nil,
+		nil,
+		props.Expression.Arguments,
+		shimast.NodeFlagsNone,
+	)
+}

package/native/transform/features/llm/LlmControllerTransformer.go

@@ -0,0 +1,59 @@
+package llm
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type llmControllerTransformerNamespace struct{}
+
+var LlmControllerTransformer = llmControllerTransformerNamespace{}
+
+func (llmControllerTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.controller")
+	if ok == false {
+		return props.Expression.AsNode()
+	}
+	llmTransformer_require_argument(props, "typia.llm.controller", 0, "no identifier name.")
+	llmTransformer_require_argument(props, "typia.llm.controller", 1, "no executor.")
+	config := llmTransformer_config(props, "controller")
+	analyze := func(validate bool) *schemametadata.MetadataSchema {
+		return llmTransformer_analyze(llmTransformer_analyzeProps{
+			Context:    props.Context,
+			Type:       typ,
+			Code:       "typia.llm.controller",
+			Absorb:     validate,
+			Functional: true,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				if validate == false {
+					return nil
+				}
+				return nativellmprogrammers.LlmApplicationProgrammer.Validate(struct {
+					Config   map[string]any
+					Metadata *schemametadata.MetadataSchema
+					Explore  nativefactories.MetadataFactory_IExplore
+					Top      *schemametadata.MetadataSchema
+				}{Config: config, Metadata: next.Metadata, Explore: next.Explore, Top: next.Top})
+			},
+		})
+	}
+	analyze(true)
+	return nativellmprogrammers.LlmControllerProgrammer.Write(nativellmprogrammers.LlmControllerProgrammer_IWriteProps{
+		Context:         props.Context,
+		Modulo:          props.Modulo,
+		Metadata:        analyze(false),
+		ClassName:       llmTransformer_type_name(top),
+		Config:          config,
+		Node:            top,
+		NameArgument:    llmTransformer_argument(props, 0),
+		ExecuteArgument: llmTransformer_argument(props, 1),
+		ConfigArgument:  llmTransformer_argument(props, 2),
+	})
+}

package/native/transform/features/llm/LlmCreateCoerceTransformer.go

@@ -0,0 +1,54 @@
+package llm
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativellmprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers/llm"
+	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+	nativetransform "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type llmCreateCoerceTransformerNamespace struct{}
+
+var LlmCreateCoerceTransformer = llmCreateCoerceTransformerNamespace{}
+
+func (llmCreateCoerceTransformerNamespace) Transform(props nativetransform.ITransformProps) *shimast.Node {
+	top, typ, ok := llmTransformer_type_argument(props, "typia.llm.createCoerce")
+	if ok == false {
+		return props.Expression.AsNode()
+	}
+	config := llmTransformer_config(props, "createCoerce")
+	if typ != nil && typ.IsTypeParameter() {
+		panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{Code: "typia.llm.createCoerce", Message: "non-specified generic argument."}))
+	}
+	analyze := func(validate bool) *schemametadata.MetadataSchema {
+		return llmTransformer_analyze(llmTransformer_analyzeProps{
+			Context: props.Context,
+			Type:    typ,
+			Code:    "typia.llm.createCoerce",
+			Absorb:  validate,
+			Validate: func(next struct {
+				Metadata *schemametadata.MetadataSchema
+				Explore  nativefactories.MetadataFactory_IExplore
+				Top      *schemametadata.MetadataSchema
+			}) []string {
+				if validate == false {
+					return nil
+				}
+				return nativellmprogrammers.LlmCoerceProgrammer.Validate(struct {
+					Config   map[string]any
+					Metadata *schemametadata.MetadataSchema
+					Explore  nativefactories.MetadataFactory_IExplore
+				}{Config: config, Metadata: next.Metadata, Explore: next.Explore})
+			},
+		})
+	}
+	analyze(true)
+	return nativellmprogrammers.LlmCoerceProgrammer.Write(nativellmprogrammers.LlmCoerceProgrammer_IWriteProps{
+		Context:  props.Context,
+		Modulo:   props.Modulo,
+		Metadata: analyze(false),
+		Name:     llmTransformer_type_name(top),
+		Config:   config,
+	})
+}