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

package/native/core/programmers/llm/LlmStructuredOutputProgrammer.go

@@ -1,14 +1,14 @@
 package llm
 
 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"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  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"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type llmStructuredOutputProgrammerNamespace struct{}
@@ -16,131 +16,131 @@ type llmStructuredOutputProgrammerNamespace struct{}
 var LlmStructuredOutputProgrammer = llmStructuredOutputProgrammerNamespace{}
 
 type LlmStructuredOutputProgrammer_IProps struct {
-	Context nativecontext.ITypiaContext
-	Modulo  *shimast.Node
-	Type    *shimchecker.Type
-	Name    *string
-	Init    *shimast.Node
-	Config  map[string]any
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Type    *shimchecker.Type
+  Name    *string
+  Init    *shimast.Node
+  Config  map[string]any
 }
 
 type LlmStructuredOutputProgrammer_IWriteProps struct {
-	Context  nativecontext.ITypiaContext
-	Modulo   *shimast.Node
-	Type     *shimchecker.Type
-	Metadata *schemametadata.MetadataSchema
-	Config   map[string]any
-	Name     *string
+  Context  nativecontext.ITypiaContext
+  Modulo   *shimast.Node
+  Type     *shimchecker.Type
+  Metadata *schemametadata.MetadataSchema
+  Config   map[string]any
+  Name     *string
 }
 
 var llmStructuredOutputProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (llmStructuredOutputProgrammerNamespace) Write(props LlmStructuredOutputProgrammer_IWriteProps) *shimast.Node {
-	functor := nativehelpers.NewFunctionProgrammer(llmProgrammer_method_text(props.Modulo))
-	equals := false
-	if props.Config != nil {
-		if v, ok := props.Config["equals"].(bool); ok {
-			equals = v
-		}
-	}
-	validateDecomposed := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
-		Context: props.Context,
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: equals},
-		Type:    props.Type,
-		Name:    props.Name,
-	})
-	typeName := "unknown"
-	if props.Name != nil {
-		typeName = *props.Name
-	}
-	statements := []*shimast.Node{
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-			Name: "__parameters",
-			Type: llmProgrammer_import_type(props.Context, ImportTypeIParameters()),
-			Value: LlmParametersProgrammer.WriteParametersExpression(LlmParametersProgrammer_IWriteProps{
-				Context:  props.Context,
-				Metadata: props.Metadata,
-				Config:   props.Config,
-			}),
-		}),
-	}
-	statements = append(statements, validateDecomposed.Statements...)
-	statements = append(statements, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-		Name:  "__validate",
-		Value: validateDecomposed.Arrow,
-	}))
-	result := nativeinternal.FeatureProgrammer_IDecomposed{
-		Functions:  validateDecomposed.Functions,
-		Statements: statements,
-		Arrow: llmStructuredOutputProgrammer_factory.NewAsExpression(
-			llmStructuredOutputProgrammer_factory.NewObjectLiteralExpression(llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
-				llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("parameters"), nil, nil, llmStructuredOutputProgrammer_factory.NewIdentifier("__parameters")),
-				llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("parse"), nil, nil, llmStructuredOutputProgrammer_factory.NewArrowFunction(
-					nil,
-					nil,
-					llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
-						nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("string"), nil),
-					}),
-					llmProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
-						File:      "typia",
-						Name:      "IJsonParseResult",
-						Arguments: []*shimast.TypeNode{llmProgrammer_type_reference(typeName)},
-					}),
-					nil,
-					llmStructuredOutputProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-					llmStructuredOutputProgrammer_factory.NewCallExpression(
-						llmProgrammer_internal(props.Context, "parseLlmArguments"),
-						nil,
-						nil,
-						llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
-							llmStructuredOutputProgrammer_factory.NewIdentifier("input"),
-							llmStructuredOutputProgrammer_factory.NewIdentifier("__parameters"),
-						}),
-						shimast.NodeFlagsNone,
-					),
-				)),
-				llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("coerce"), nil, nil, llmStructuredOutputProgrammer_factory.NewArrowFunction(
-					nil,
-					nil,
-					llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
-						nativefactories.IdentifierFactory.Parameter("input", llmProgrammer_type_reference(typeName), nil),
-					}),
-					llmProgrammer_type_reference(typeName),
-					nil,
-					llmStructuredOutputProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-					llmStructuredOutputProgrammer_factory.NewCallExpression(
-						llmProgrammer_internal(props.Context, "coerceLlmArguments"),
-						nil,
-						nil,
-						llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
-							llmStructuredOutputProgrammer_factory.NewIdentifier("input"),
-							llmStructuredOutputProgrammer_factory.NewIdentifier("__parameters"),
-						}),
-						shimast.NodeFlagsNone,
-					),
-				)),
-				llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("validate"), nil, nil, llmStructuredOutputProgrammer_factory.NewIdentifier("__validate")),
-			}), true),
-			llmProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
-				File:      "typia",
-				Name:      "ILlmStructuredOutput",
-				Arguments: []*shimast.TypeNode{llmProgrammer_type_reference(typeName)},
-			}),
-		),
-	}
-	return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-		Modulo:  props.Modulo,
-		Functor: functor,
-		Result:  result,
-	})
+  functor := nativehelpers.NewFunctionProgrammer(llmProgrammer_method_text(props.Modulo))
+  equals := false
+  if props.Config != nil {
+    if v, ok := props.Config["equals"].(bool); ok {
+      equals = v
+    }
+  }
+  validateDecomposed := nativeprogrammers.ValidateProgrammer.Decompose(nativeprogrammers.ValidateProgrammer_DecomposeProps{
+    Context: props.Context,
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: equals},
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  typeName := "unknown"
+  if props.Name != nil {
+    typeName = *props.Name
+  }
+  statements := []*shimast.Node{
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: "__parameters",
+      Type: llmProgrammer_import_type(props.Context, ImportTypeIParameters()),
+      Value: LlmParametersProgrammer.WriteParametersExpression(LlmParametersProgrammer_IWriteProps{
+        Context:  props.Context,
+        Metadata: props.Metadata,
+        Config:   props.Config,
+      }),
+    }),
+  }
+  statements = append(statements, validateDecomposed.Statements...)
+  statements = append(statements, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+    Name:  "__validate",
+    Value: validateDecomposed.Arrow,
+  }))
+  result := nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  validateDecomposed.Functions,
+    Statements: statements,
+    Arrow: llmStructuredOutputProgrammer_factory.NewAsExpression(
+      llmStructuredOutputProgrammer_factory.NewObjectLiteralExpression(llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
+        llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("parameters"), nil, nil, llmStructuredOutputProgrammer_factory.NewIdentifier("__parameters")),
+        llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("parse"), nil, nil, llmStructuredOutputProgrammer_factory.NewArrowFunction(
+          nil,
+          nil,
+          llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter("input", nativefactories.TypeFactory.Keyword("string"), nil),
+          }),
+          llmProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+            File:      "typia",
+            Name:      "IJsonParseResult",
+            Arguments: []*shimast.TypeNode{llmProgrammer_type_reference(typeName)},
+          }),
+          nil,
+          llmStructuredOutputProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+          llmStructuredOutputProgrammer_factory.NewCallExpression(
+            llmProgrammer_internal(props.Context, "parseLlmArguments"),
+            nil,
+            nil,
+            llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
+              llmStructuredOutputProgrammer_factory.NewIdentifier("input"),
+              llmStructuredOutputProgrammer_factory.NewIdentifier("__parameters"),
+            }),
+            shimast.NodeFlagsNone,
+          ),
+        )),
+        llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("coerce"), nil, nil, llmStructuredOutputProgrammer_factory.NewArrowFunction(
+          nil,
+          nil,
+          llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter("input", llmProgrammer_type_reference(typeName), nil),
+          }),
+          llmProgrammer_type_reference(typeName),
+          nil,
+          llmStructuredOutputProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+          llmStructuredOutputProgrammer_factory.NewCallExpression(
+            llmProgrammer_internal(props.Context, "coerceLlmArguments"),
+            nil,
+            nil,
+            llmStructuredOutputProgrammer_factory.NewNodeList([]*shimast.Node{
+              llmStructuredOutputProgrammer_factory.NewIdentifier("input"),
+              llmStructuredOutputProgrammer_factory.NewIdentifier("__parameters"),
+            }),
+            shimast.NodeFlagsNone,
+          ),
+        )),
+        llmStructuredOutputProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("validate"), nil, nil, llmStructuredOutputProgrammer_factory.NewIdentifier("__validate")),
+      }), true),
+      llmProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+        File:      "typia",
+        Name:      "ILlmStructuredOutput",
+        Arguments: []*shimast.TypeNode{llmProgrammer_type_reference(typeName)},
+      }),
+    ),
+  }
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
 }
 
 func (llmStructuredOutputProgrammerNamespace) Validate(props struct {
-	Config   map[string]any
-	Metadata *schemametadata.MetadataSchema
-	Explore  nativefactories.MetadataFactory_IExplore
+  Config   map[string]any
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativefactories.MetadataFactory_IExplore
 }) []string {
-	return LlmParametersProgrammer.Validate(props)
+  return LlmParametersProgrammer.Validate(props)
 }

package/native/core/programmers/misc/MiscAssertCloneProgrammer.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 miscAssertCloneProgrammerNamespace struct{}
@@ -15,87 +15,87 @@ type miscAssertCloneProgrammerNamespace struct{}
 var MiscAssertCloneProgrammer = miscAssertCloneProgrammerNamespace{}
 
 type MiscAssertCloneProgrammer_DecomposeProps struct {
-	Context nativecontext.ITypiaContext
-	Functor *nativehelpers.FunctionProgrammer
-	Type    *shimchecker.Type
-	Name    *string
-	Init    *shimast.Node
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
+  Init    *shimast.Node
 }
 
 var miscAssertCloneProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (miscAssertCloneProgrammerNamespace) Decompose(props MiscAssertCloneProgrammer_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,
-	})
-	clone := MiscCloneProgrammer.Decompose(MiscCloneProgrammer_DecomposeProps{
-		Context:   props.Context,
-		Functor:   props.Functor,
-		Type:      props.Type,
-		Name:      props.Name,
-		Validated: true,
-	})
-	statements := append([]*shimast.Node{}, assert.Statements...)
-	statements = append(statements, clone.Statements...)
-	statements = append(statements,
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__assert", Value: assert.Arrow}),
-		nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__clone", Value: clone.Arrow}),
-	)
-	return nativeinternal.FeatureProgrammer_IDecomposed{
-		Functions:  miscProgrammer_merge_functions(assert.Functions, clone.Functions),
-		Statements: statements,
-		Arrow: miscAssertCloneProgrammer_factory.NewArrowFunction(
-			nil,
-			nil,
-			miscAssertCloneProgrammer_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}),
-			}),
-			clone.Arrow.AsArrowFunction().Type,
-			nil,
-			miscAssertCloneProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
-			miscAssertCloneProgrammer_factory.NewCallExpression(
-				miscAssertCloneProgrammer_factory.NewIdentifier("__clone"),
-				nil,
-				nil,
-				miscAssertCloneProgrammer_factory.NewNodeList([]*shimast.Node{
-					miscAssertCloneProgrammer_factory.NewCallExpression(
-						miscAssertCloneProgrammer_factory.NewIdentifier("__assert"),
-						nil,
-						nil,
-						miscAssertCloneProgrammer_factory.NewNodeList([]*shimast.Node{
-							miscAssertCloneProgrammer_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,
+  })
+  clone := MiscCloneProgrammer.Decompose(MiscCloneProgrammer_DecomposeProps{
+    Context:   props.Context,
+    Functor:   props.Functor,
+    Type:      props.Type,
+    Name:      props.Name,
+    Validated: true,
+  })
+  statements := append([]*shimast.Node{}, assert.Statements...)
+  statements = append(statements, clone.Statements...)
+  statements = append(statements,
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__assert", Value: assert.Arrow}),
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{Name: "__clone", Value: clone.Arrow}),
+  )
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  miscProgrammer_merge_functions(assert.Functions, clone.Functions),
+    Statements: statements,
+    Arrow: miscAssertCloneProgrammer_factory.NewArrowFunction(
+      nil,
+      nil,
+      miscAssertCloneProgrammer_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}),
+      }),
+      clone.Arrow.AsArrowFunction().Type,
+      nil,
+      miscAssertCloneProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+      miscAssertCloneProgrammer_factory.NewCallExpression(
+        miscAssertCloneProgrammer_factory.NewIdentifier("__clone"),
+        nil,
+        nil,
+        miscAssertCloneProgrammer_factory.NewNodeList([]*shimast.Node{
+          miscAssertCloneProgrammer_factory.NewCallExpression(
+            miscAssertCloneProgrammer_factory.NewIdentifier("__assert"),
+            nil,
+            nil,
+            miscAssertCloneProgrammer_factory.NewNodeList([]*shimast.Node{
+              miscAssertCloneProgrammer_factory.NewIdentifier("input"),
+              nativeprogrammers.Guardian.Identifier(),
+            }),
+            shimast.NodeFlagsNone,
+          ),
+        }),
+        shimast.NodeFlagsNone,
+      ),
+    ),
+  }
 }
 
 func (miscAssertCloneProgrammerNamespace) Write(props nativecontext.IProgrammerProps) *shimast.Node {
-	functor := nativehelpers.NewFunctionProgrammer(miscCloneProgrammer_method_text(props.Modulo))
-	result := MiscAssertCloneProgrammer.Decompose(MiscAssertCloneProgrammer_DecomposeProps{
-		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(miscCloneProgrammer_method_text(props.Modulo))
+  result := MiscAssertCloneProgrammer.Decompose(MiscAssertCloneProgrammer_DecomposeProps{
+    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,
+  })
 }