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

package/native/core/schemas/metadata/MetadataComponents.go

@@ -1,122 +1,122 @@
 package metadata
 
 type IMetadataComponents struct {
-	Objects []IMetadataSchema_IObjectType
-	Aliases []IMetadataSchema_IAliasType
-	Arrays  []IMetadataSchema_IArrayType
-	Tuples  []IMetadataSchema_ITupleType
+  Objects []IMetadataSchema_IObjectType
+  Aliases []IMetadataSchema_IAliasType
+  Arrays  []IMetadataSchema_IArrayType
+  Tuples  []IMetadataSchema_ITupleType
 }
 
 type MetadataComponents struct {
-	Aliases    []*MetadataAliasType
-	Objects    []*MetadataObjectType
-	Arrays     []*MetadataArrayType
-	Tuples     []*MetadataTupleType
-	Dictionary IMetadataDictionary
+  Aliases    []*MetadataAliasType
+  Objects    []*MetadataObjectType
+  Arrays     []*MetadataArrayType
+  Tuples     []*MetadataTupleType
+  Dictionary IMetadataDictionary
 }
 
 func MetadataComponents_from(json IMetadataComponents) *MetadataComponents {
-	dictionary := IMetadataDictionary{
-		Objects: map[string]*MetadataObjectType{},
-		Aliases: map[string]*MetadataAliasType{},
-		Arrays:  map[string]*MetadataArrayType{},
-		Tuples:  map[string]*MetadataTupleType{},
-	}
-	for _, obj := range json.Objects {
-		dictionary.Objects[obj.Name] = MetadataObjectType__From_without_properties(obj)
-	}
-	for _, alias := range json.Aliases {
-		dictionary.Aliases[alias.Name] = MetadataAliasType__From_without_value(alias)
-	}
-	for _, array := range json.Arrays {
-		dictionary.Arrays[array.Name] = MetadataArrayType__From_without_value(array)
-	}
-	for _, tuple := range json.Tuples {
-		dictionary.Tuples[tuple.Name] = MetadataTupleType__From_without_elements(tuple)
-	}
+  dictionary := IMetadataDictionary{
+    Objects: map[string]*MetadataObjectType{},
+    Aliases: map[string]*MetadataAliasType{},
+    Arrays:  map[string]*MetadataArrayType{},
+    Tuples:  map[string]*MetadataTupleType{},
+  }
+  for _, obj := range json.Objects {
+    dictionary.Objects[obj.Name] = MetadataObjectType__From_without_properties(obj)
+  }
+  for _, alias := range json.Aliases {
+    dictionary.Aliases[alias.Name] = MetadataAliasType__From_without_value(alias)
+  }
+  for _, array := range json.Arrays {
+    dictionary.Arrays[array.Name] = MetadataArrayType__From_without_value(array)
+  }
+  for _, tuple := range json.Tuples {
+    dictionary.Tuples[tuple.Name] = MetadataTupleType__From_without_elements(tuple)
+  }
 
-	for _, obj := range json.Objects {
-		target := dictionary.Objects[obj.Name]
-		for _, prop := range obj.Properties {
-			target.Properties = append(target.Properties, MetadataProperty_from(*prop, dictionary))
-		}
-	}
-	for _, alias := range json.Aliases {
-		dictionary.Aliases[alias.Name].Value = MetadataSchema_from(alias.Value, dictionary)
-	}
-	for _, array := range json.Arrays {
-		dictionary.Arrays[array.Name].Value = MetadataSchema_from(array.Value, dictionary)
-	}
-	for _, tuple := range json.Tuples {
-		elements := make([]*MetadataSchema, 0, len(tuple.Elements))
-		for _, elem := range tuple.Elements {
-			elements = append(elements, MetadataSchema_from(elem, dictionary))
-		}
-		dictionary.Tuples[tuple.Name].Elements = elements
-	}
+  for _, obj := range json.Objects {
+    target := dictionary.Objects[obj.Name]
+    for _, prop := range obj.Properties {
+      target.Properties = append(target.Properties, MetadataProperty_from(*prop, dictionary))
+    }
+  }
+  for _, alias := range json.Aliases {
+    dictionary.Aliases[alias.Name].Value = MetadataSchema_from(alias.Value, dictionary)
+  }
+  for _, array := range json.Arrays {
+    dictionary.Arrays[array.Name].Value = MetadataSchema_from(array.Value, dictionary)
+  }
+  for _, tuple := range json.Tuples {
+    elements := make([]*MetadataSchema, 0, len(tuple.Elements))
+    for _, elem := range tuple.Elements {
+      elements = append(elements, MetadataSchema_from(elem, dictionary))
+    }
+    dictionary.Tuples[tuple.Name].Elements = elements
+  }
 
-	return &MetadataComponents{
-		Aliases:    metadataComponents_aliases(dictionary.Aliases),
-		Objects:    metadataComponents_objects(dictionary.Objects),
-		Arrays:     metadataComponents_arrays(dictionary.Arrays),
-		Tuples:     metadataComponents_tuples(dictionary.Tuples),
-		Dictionary: dictionary,
-	}
+  return &MetadataComponents{
+    Aliases:    metadataComponents_aliases(dictionary.Aliases),
+    Objects:    metadataComponents_objects(dictionary.Objects),
+    Arrays:     metadataComponents_arrays(dictionary.Arrays),
+    Tuples:     metadataComponents_tuples(dictionary.Tuples),
+    Dictionary: dictionary,
+  }
 }
 
 func (components *MetadataComponents) ToJSON() IMetadataComponents {
-	aliases := make([]IMetadataSchema_IAliasType, 0, len(components.Aliases))
-	for _, alias := range components.Aliases {
-		aliases = append(aliases, alias.ToJSON())
-	}
-	objects := make([]IMetadataSchema_IObjectType, 0, len(components.Objects))
-	for _, object := range components.Objects {
-		objects = append(objects, object.ToJSON())
-	}
-	arrays := make([]IMetadataSchema_IArrayType, 0, len(components.Arrays))
-	for _, array := range components.Arrays {
-		arrays = append(arrays, array.ToJSON())
-	}
-	tuples := make([]IMetadataSchema_ITupleType, 0, len(components.Tuples))
-	for _, tuple := range components.Tuples {
-		tuples = append(tuples, tuple.ToJSON())
-	}
-	return IMetadataComponents{
-		Aliases: aliases,
-		Objects: objects,
-		Arrays:  arrays,
-		Tuples:  tuples,
-	}
+  aliases := make([]IMetadataSchema_IAliasType, 0, len(components.Aliases))
+  for _, alias := range components.Aliases {
+    aliases = append(aliases, alias.ToJSON())
+  }
+  objects := make([]IMetadataSchema_IObjectType, 0, len(components.Objects))
+  for _, object := range components.Objects {
+    objects = append(objects, object.ToJSON())
+  }
+  arrays := make([]IMetadataSchema_IArrayType, 0, len(components.Arrays))
+  for _, array := range components.Arrays {
+    arrays = append(arrays, array.ToJSON())
+  }
+  tuples := make([]IMetadataSchema_ITupleType, 0, len(components.Tuples))
+  for _, tuple := range components.Tuples {
+    tuples = append(tuples, tuple.ToJSON())
+  }
+  return IMetadataComponents{
+    Aliases: aliases,
+    Objects: objects,
+    Arrays:  arrays,
+    Tuples:  tuples,
+  }
 }
 
 func metadataComponents_aliases(input map[string]*MetadataAliasType) []*MetadataAliasType {
-	output := make([]*MetadataAliasType, 0, len(input))
-	for _, value := range input {
-		output = append(output, value)
-	}
-	return output
+  output := make([]*MetadataAliasType, 0, len(input))
+  for _, value := range input {
+    output = append(output, value)
+  }
+  return output
 }
 
 func metadataComponents_objects(input map[string]*MetadataObjectType) []*MetadataObjectType {
-	output := make([]*MetadataObjectType, 0, len(input))
-	for _, value := range input {
-		output = append(output, value)
-	}
-	return output
+  output := make([]*MetadataObjectType, 0, len(input))
+  for _, value := range input {
+    output = append(output, value)
+  }
+  return output
 }
 
 func metadataComponents_arrays(input map[string]*MetadataArrayType) []*MetadataArrayType {
-	output := make([]*MetadataArrayType, 0, len(input))
-	for _, value := range input {
-		output = append(output, value)
-	}
-	return output
+  output := make([]*MetadataArrayType, 0, len(input))
+  for _, value := range input {
+    output = append(output, value)
+  }
+  return output
 }
 
 func metadataComponents_tuples(input map[string]*MetadataTupleType) []*MetadataTupleType {
-	output := make([]*MetadataTupleType, 0, len(input))
-	for _, value := range input {
-		output = append(output, value)
-	}
-	return output
+  output := make([]*MetadataTupleType, 0, len(input))
+  for _, value := range input {
+    output = append(output, value)
+  }
+  return output
 }

package/native/core/schemas/metadata/MetadataConstant.go

@@ -1,47 +1,47 @@
 package metadata
 
 type IMetadataSchema_IConstant struct {
-	Type   string
-	Values []IMetadataSchema_IConstant_IValue
+  Type   string
+  Values []IMetadataSchema_IConstant_IValue
 }
 
 type MetadataConstant struct {
-	Type   string
-	Values []*MetadataConstantValue
+  Type   string
+  Values []*MetadataConstantValue
 }
 
 func MetadataConstant_create(props MetadataConstant) *MetadataConstant {
-	values := make([]*MetadataConstantValue, 0, len(props.Values))
-	for _, value := range props.Values {
-		if value == nil {
-			continue
-		}
-		values = append(values, MetadataConstantValue_create(*value))
-	}
-	return &MetadataConstant{
-		Type:   props.Type,
-		Values: values,
-	}
+  values := make([]*MetadataConstantValue, 0, len(props.Values))
+  for _, value := range props.Values {
+    if value == nil {
+      continue
+    }
+    values = append(values, MetadataConstantValue_create(*value))
+  }
+  return &MetadataConstant{
+    Type:   props.Type,
+    Values: values,
+  }
 }
 
 func MetadataConstant_from(json IMetadataSchema_IConstant) *MetadataConstant {
-	values := make([]*MetadataConstantValue, 0, len(json.Values))
-	for _, value := range json.Values {
-		values = append(values, MetadataConstantValue_from(value))
-	}
-	return MetadataConstant_create(MetadataConstant{
-		Type:   json.Type,
-		Values: values,
-	})
+  values := make([]*MetadataConstantValue, 0, len(json.Values))
+  for _, value := range json.Values {
+    values = append(values, MetadataConstantValue_from(value))
+  }
+  return MetadataConstant_create(MetadataConstant{
+    Type:   json.Type,
+    Values: values,
+  })
 }
 
 func (obj *MetadataConstant) ToJSON() IMetadataSchema_IConstant {
-	values := make([]IMetadataSchema_IConstant_IValue, 0, len(obj.Values))
-	for _, value := range obj.Values {
-		values = append(values, value.ToJSON())
-	}
-	return IMetadataSchema_IConstant{
-		Type:   obj.Type,
-		Values: values,
-	}
+  values := make([]IMetadataSchema_IConstant_IValue, 0, len(obj.Values))
+  for _, value := range obj.Values {
+    values = append(values, value.ToJSON())
+  }
+  return IMetadataSchema_IConstant{
+    Type:   obj.Type,
+    Values: values,
+  }
 }

package/native/core/schemas/metadata/MetadataConstantValue.go

@@ -1,97 +1,97 @@
 package metadata
 
 import (
-	"encoding/json"
-	"fmt"
-	"strings"
+  "encoding/json"
+  "fmt"
+  "strings"
 )
 
 type IJsDocTagInfo struct {
-	Name string
-	Text []IJsDocTagInfo_IText
+  Name string
+  Text []IJsDocTagInfo_IText
 }
 
 type IJsDocTagInfo_IText struct {
-	Text string
-	Kind string
+  Text string
+  Kind string
 }
 
 type IMetadataSchema_IConstant_IValue struct {
-	Value       any
-	Tags        [][]IMetadataTypeTag
-	Description *string
-	JsDocTags   []IJsDocTagInfo
+  Value       any
+  Tags        [][]IMetadataTypeTag
+  Description *string
+  JsDocTags   []IJsDocTagInfo
 }
 
 type MetadataConstantValue struct {
-	Value       any
-	Tags        [][]IMetadataTypeTag
-	Description *string
-	JsDocTags   []IJsDocTagInfo
-	name_       string
+  Value       any
+  Tags        [][]IMetadataTypeTag
+  Description *string
+  JsDocTags   []IJsDocTagInfo
+  name_       string
 }
 
 func MetadataConstantValue_create(props MetadataConstantValue) *MetadataConstantValue {
-	return &MetadataConstantValue{
-		Value:       props.Value,
-		Tags:        props.Tags,
-		Description: props.Description,
-		JsDocTags:   props.JsDocTags,
-	}
+  return &MetadataConstantValue{
+    Value:       props.Value,
+    Tags:        props.Tags,
+    Description: props.Description,
+    JsDocTags:   props.JsDocTags,
+  }
 }
 
 func MetadataConstantValue_from(json IMetadataSchema_IConstant_IValue) *MetadataConstantValue {
-	return MetadataConstantValue_create(MetadataConstantValue{
-		Value:       json.Value,
-		Tags:        json.Tags,
-		Description: json.Description,
-		JsDocTags:   json.JsDocTags,
-	})
+  return MetadataConstantValue_create(MetadataConstantValue{
+    Value:       json.Value,
+    Tags:        json.Tags,
+    Description: json.Description,
+    JsDocTags:   json.JsDocTags,
+  })
 }
 
 func (obj *MetadataConstantValue) GetName() string {
-	if obj.name_ == "" {
-		obj.name_ = metadataConstantValue_getName(obj)
-	}
-	return obj.name_
+  if obj.name_ == "" {
+    obj.name_ = metadataConstantValue_getName(obj)
+  }
+  return obj.name_
 }
 
 func (obj *MetadataConstantValue) ToJSON() IMetadataSchema_IConstant_IValue {
-	return IMetadataSchema_IConstant_IValue{
-		Value:       obj.Value,
-		Tags:        obj.Tags,
-		Description: obj.Description,
-		JsDocTags:   obj.JsDocTags,
-	}
+  return IMetadataSchema_IConstant_IValue{
+    Value:       obj.Value,
+    Tags:        obj.Tags,
+    Description: obj.Description,
+    JsDocTags:   obj.JsDocTags,
+  }
 }
 
 func metadataConstantValue_getName(obj *MetadataConstantValue) string {
-	base := metadataConstantValue_base(obj.Value)
-	if len(obj.Tags) == 0 {
-		return base
-	}
-	rows := make([]string, 0, len(obj.Tags))
-	for _, row := range obj.Tags {
-		names := make([]string, 0, len(row))
-		for _, tag := range row {
-			names = append(names, tag.Name)
-		}
-		str := strings.Join(names, " & ")
-		if len(row) == 1 {
-			rows = append(rows, str)
-		} else {
-			rows = append(rows, "("+str+")")
-		}
-	}
-	return "(" + base + " & (" + strings.Join(rows, " | ") + "))"
+  base := metadataConstantValue_base(obj.Value)
+  if len(obj.Tags) == 0 {
+    return base
+  }
+  rows := make([]string, 0, len(obj.Tags))
+  for _, row := range obj.Tags {
+    names := make([]string, 0, len(row))
+    for _, tag := range row {
+      names = append(names, tag.Name)
+    }
+    str := strings.Join(names, " & ")
+    if len(row) == 1 {
+      rows = append(rows, str)
+    } else {
+      rows = append(rows, "("+str+")")
+    }
+  }
+  return "(" + base + " & (" + strings.Join(rows, " | ") + "))"
 }
 
 func metadataConstantValue_base(value any) string {
-	if str, ok := value.(string); ok {
-		data, err := json.Marshal(str)
-		if err == nil {
-			return string(data)
-		}
-	}
-	return fmt.Sprint(value)
+  if str, ok := value.(string); ok {
+    data, err := json.Marshal(str)
+    if err == nil {
+      return string(data)
+    }
+  }
+  return fmt.Sprint(value)
 }

package/native/core/schemas/metadata/MetadataEscaped.go

@@ -1,36 +1,36 @@
 package metadata
 
 type IMetadataSchema_IEscaped struct {
-	Original *IMetadataSchema
-	Returns  *IMetadataSchema
+  Original *IMetadataSchema
+  Returns  *IMetadataSchema
 }
 
 type MetadataEscaped struct {
-	Original *MetadataSchema
-	Returns  *MetadataSchema
+  Original *MetadataSchema
+  Returns  *MetadataSchema
 }
 
 func MetadataEscaped_from(props IMetadataSchema_IEscaped, dict IMetadataDictionary) *MetadataEscaped {
-	return MetadataEscaped_create(MetadataEscaped{
-		Original: MetadataSchema_from(props.Original, dict),
-		Returns:  MetadataSchema_from(props.Returns, dict),
-	})
+  return MetadataEscaped_create(MetadataEscaped{
+    Original: MetadataSchema_from(props.Original, dict),
+    Returns:  MetadataSchema_from(props.Returns, dict),
+  })
 }
 
 func MetadataEscaped_create(props MetadataEscaped) *MetadataEscaped {
-	return &MetadataEscaped{
-		Original: props.Original,
-		Returns:  props.Returns,
-	}
+  return &MetadataEscaped{
+    Original: props.Original,
+    Returns:  props.Returns,
+  }
 }
 
 func (obj *MetadataEscaped) GetName() string {
-	return obj.Returns.GetName()
+  return obj.Returns.GetName()
 }
 
 func (obj *MetadataEscaped) ToJSON() IMetadataSchema_IEscaped {
-	return IMetadataSchema_IEscaped{
-		Original: obj.Original.ToJSON(),
-		Returns:  obj.Returns.ToJSON(),
-	}
+  return IMetadataSchema_IEscaped{
+    Original: obj.Original.ToJSON(),
+    Returns:  obj.Returns.ToJSON(),
+  }
 }

package/native/core/schemas/metadata/MetadataFunction.go

@@ -1,46 +1,46 @@
 package metadata
 
 type IMetadataSchema_IFunction struct {
-	Parameters []*IMetadataSchema_IParameter
-	Output     *IMetadataSchema
-	Async      bool
+  Parameters []*IMetadataSchema_IParameter
+  Output     *IMetadataSchema
+  Async      bool
 }
 
 type MetadataFunction struct {
-	Parameters []*MetadataParameter
-	Output     *MetadataSchema
-	Async      bool
+  Parameters []*MetadataParameter
+  Output     *MetadataSchema
+  Async      bool
 }
 
 func MetadataFunction_create(props MetadataFunction) *MetadataFunction {
-	return &MetadataFunction{
-		Parameters: props.Parameters,
-		Output:     props.Output,
-		Async:      props.Async,
-	}
+  return &MetadataFunction{
+    Parameters: props.Parameters,
+    Output:     props.Output,
+    Async:      props.Async,
+  }
 }
 
 func MetadataFunction_from(json IMetadataSchema_IFunction, dict IMetadataDictionary) *MetadataFunction {
-	parameters := make([]*MetadataParameter, 0, len(json.Parameters))
-	for _, p := range json.Parameters {
-		parameters = append(parameters, MetadataParameter_from(*p, dict))
-	}
-	return MetadataFunction_create(MetadataFunction{
-		Parameters: parameters,
-		Output:     MetadataSchema_from(json.Output, dict),
-		Async:      json.Async,
-	})
+  parameters := make([]*MetadataParameter, 0, len(json.Parameters))
+  for _, p := range json.Parameters {
+    parameters = append(parameters, MetadataParameter_from(*p, dict))
+  }
+  return MetadataFunction_create(MetadataFunction{
+    Parameters: parameters,
+    Output:     MetadataSchema_from(json.Output, dict),
+    Async:      json.Async,
+  })
 }
 
 func (obj *MetadataFunction) ToJSON() IMetadataSchema_IFunction {
-	parameters := make([]*IMetadataSchema_IParameter, 0, len(obj.Parameters))
-	for _, p := range obj.Parameters {
-		json := p.ToJSON()
-		parameters = append(parameters, &json)
-	}
-	return IMetadataSchema_IFunction{
-		Parameters: parameters,
-		Output:     obj.Output.ToJSON(),
-		Async:      obj.Async,
-	}
+  parameters := make([]*IMetadataSchema_IParameter, 0, len(obj.Parameters))
+  for _, p := range obj.Parameters {
+    json := p.ToJSON()
+    parameters = append(parameters, &json)
+  }
+  return IMetadataSchema_IFunction{
+    Parameters: parameters,
+    Output:     obj.Output.ToJSON(),
+    Async:      obj.Async,
+  }
 }

package/native/core/schemas/metadata/MetadataMap.go

@@ -1,37 +1,37 @@
 package metadata
 
 type IMetadataSchema_IMap struct {
-	Key   *IMetadataSchema
-	Value *IMetadataSchema
-	Tags  [][]IMetadataTypeTag
+  Key   *IMetadataSchema
+  Value *IMetadataSchema
+  Tags  [][]IMetadataTypeTag
 }
 
 type MetadataMap struct {
-	Key   *MetadataSchema
-	Value *MetadataSchema
-	Tags  [][]IMetadataTypeTag
-	name_ string
+  Key   *MetadataSchema
+  Value *MetadataSchema
+  Tags  [][]IMetadataTypeTag
+  name_ string
 }
 
 func MetadataMap_create(props MetadataMap) *MetadataMap {
-	return &MetadataMap{
-		Key:   props.Key,
-		Value: props.Value,
-		Tags:  cloneTagMatrix(props.Tags),
-	}
+  return &MetadataMap{
+    Key:   props.Key,
+    Value: props.Value,
+    Tags:  cloneTagMatrix(props.Tags),
+  }
 }
 
 func (obj *MetadataMap) GetName() string {
-	if obj.name_ == "" {
-		obj.name_ = taggedName("Map<"+safeMetadataName(obj.Key)+", "+safeMetadataName(obj.Value)+">", obj.Tags)
-	}
-	return obj.name_
+  if obj.name_ == "" {
+    obj.name_ = taggedName("Map<"+safeMetadataName(obj.Key)+", "+safeMetadataName(obj.Value)+">", obj.Tags)
+  }
+  return obj.name_
 }
 
 func (obj *MetadataMap) ToJSON() IMetadataSchema_IMap {
-	return IMetadataSchema_IMap{
-		Key:   obj.Key.ToJSON(),
-		Value: obj.Value.ToJSON(),
-		Tags:  cloneTagMatrix(obj.Tags),
-	}
+  return IMetadataSchema_IMap{
+    Key:   obj.Key.ToJSON(),
+    Value: obj.Value.ToJSON(),
+    Tags:  cloneTagMatrix(obj.Tags),
+  }
 }