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

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

@@ -3,70 +3,70 @@ package metadata
 import "strings"
 
 type IMetadataTypeTag struct {
-	Target    string
-	Name      string
-	Kind      string
-	Exclusive any
-	Value     any
-	Validate  string
-	Schema    any
+  Target    string
+  Name      string
+  Kind      string
+  Exclusive any
+  Value     any
+  Validate  string
+  Schema    any
 }
 
 type IMetadataSchema_IReference struct {
-	Name string
-	Tags [][]IMetadataTypeTag
+  Name string
+  Tags [][]IMetadataTypeTag
 }
 
 type MetadataNative struct {
-	Name      string
-	Tags      [][]IMetadataTypeTag
-	typeName_ string
+  Name      string
+  Tags      [][]IMetadataTypeTag
+  typeName_ string
 }
 
 func MetadataNative_create(props MetadataNative) *MetadataNative {
-	return &MetadataNative{
-		Name: props.Name,
-		Tags: props.Tags,
-	}
+  return &MetadataNative{
+    Name: props.Name,
+    Tags: props.Tags,
+  }
 }
 
 func (obj *MetadataNative) GetName() string {
-	if obj.typeName_ == "" {
-		obj.typeName_ = metadataNative_getName(obj)
-	}
-	return obj.typeName_
+  if obj.typeName_ == "" {
+    obj.typeName_ = metadataNative_getName(obj)
+  }
+  return obj.typeName_
 }
 
 func (obj *MetadataNative) ToJSON() IMetadataSchema_IReference {
-	return IMetadataSchema_IReference{
-		Name: obj.Name,
-		Tags: obj.Tags,
-	}
+  return IMetadataSchema_IReference{
+    Name: obj.Name,
+    Tags: obj.Tags,
+  }
 }
 
 func metadataNative_getName(obj *MetadataNative) string {
-	if len(obj.Tags) == 0 {
-		return obj.Name
-	}
-	if len(obj.Tags) == 1 {
-		row := []string{obj.Name}
-		for _, tag := range obj.Tags[0] {
-			row = append(row, tag.Name)
-		}
-		return "(" + strings.Join(row, " & ") + ")"
-	}
-	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 "(" + obj.Name + " & (" + strings.Join(rows, " | ") + "))"
+  if len(obj.Tags) == 0 {
+    return obj.Name
+  }
+  if len(obj.Tags) == 1 {
+    row := []string{obj.Name}
+    for _, tag := range obj.Tags[0] {
+      row = append(row, tag.Name)
+    }
+    return "(" + strings.Join(row, " & ") + ")"
+  }
+  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 "(" + obj.Name + " & (" + strings.Join(rows, " | ") + "))"
 }

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

@@ -1,28 +1,28 @@
 package metadata
 
 type MetadataObject struct {
-	Type  *MetadataObjectType
-	Tags  [][]IMetadataTypeTag
-	name_ string
+  Type  *MetadataObjectType
+  Tags  [][]IMetadataTypeTag
+  name_ string
 }
 
 func MetadataObject_create(props MetadataObject) *MetadataObject {
-	return &MetadataObject{
-		Type: props.Type,
-		Tags: cloneTagMatrix(props.Tags),
-	}
+  return &MetadataObject{
+    Type: props.Type,
+    Tags: cloneTagMatrix(props.Tags),
+  }
 }
 
 func (obj *MetadataObject) GetName() string {
-	if obj.name_ == "" {
-		obj.name_ = taggedName(obj.Type.Name, obj.Tags)
-	}
-	return obj.name_
+  if obj.name_ == "" {
+    obj.name_ = taggedName(obj.Type.Name, obj.Tags)
+  }
+  return obj.name_
 }
 
 func (obj *MetadataObject) ToJSON() IMetadataSchema_IReference {
-	return IMetadataSchema_IReference{
-		Name: obj.Type.Name,
-		Tags: cloneTagMatrix(obj.Tags),
-	}
+  return IMetadataSchema_IReference{
+    Name: obj.Type.Name,
+    Tags: cloneTagMatrix(obj.Tags),
+  }
 }

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

@@ -3,144 +3,144 @@ package metadata
 import "strings"
 
 type IMetadataSchema_IObjectType struct {
-	Name        string
-	Properties  []*IMetadataSchema_IProperty
-	Description *string
-	JsDocTags   []IJsDocTagInfo
-	Index       int
-	Recursive   bool
-	Nullables   []bool
+  Name        string
+  Properties  []*IMetadataSchema_IProperty
+  Description *string
+  JsDocTags   []IJsDocTagInfo
+  Index       int
+  Recursive   bool
+  Nullables   []bool
 }
 
 type MetadataObjectType struct {
-	Name        string
-	Properties  []*MetadataProperty
-	Description *string
-	JsDocTags   []IJsDocTagInfo
-	Index       int
-	Validated   bool
-	Recursive   bool
-	Nullables   []bool
-	Tagged_     bool
-	literal_    *bool
+  Name        string
+  Properties  []*MetadataProperty
+  Description *string
+  JsDocTags   []IJsDocTagInfo
+  Index       int
+  Validated   bool
+  Recursive   bool
+  Nullables   []bool
+  Tagged_     bool
+  literal_    *bool
 }
 
 func MetadataObjectType_create(props MetadataObjectType) *MetadataObjectType {
-	name := strings.ToValidUTF8(props.Name, "__")
-	name = strings.ReplaceAll(name, "\uFFFD", "__")
-	return &MetadataObjectType{
-		Name:        name,
-		Properties:  props.Properties,
-		Description: props.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
-		Index:       props.Index,
-		Validated:   props.Validated,
-		Recursive:   props.Recursive,
-		Nullables:   append([]bool{}, props.Nullables...),
-		Tagged_:     false,
-	}
+  name := strings.ToValidUTF8(props.Name, "__")
+  name = strings.ReplaceAll(name, "\uFFFD", "__")
+  return &MetadataObjectType{
+    Name:        name,
+    Properties:  props.Properties,
+    Description: props.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+    Index:       props.Index,
+    Validated:   props.Validated,
+    Recursive:   props.Recursive,
+    Nullables:   append([]bool{}, props.Nullables...),
+    Tagged_:     false,
+  }
 }
 
 func MetadataObjectType__From_without_properties(obj IMetadataSchema_IObjectType) *MetadataObjectType {
-	return MetadataObjectType_create(MetadataObjectType{
-		Name:        obj.Name,
-		Properties:  []*MetadataProperty{},
-		Description: obj.Description,
-		JsDocTags:   obj.JsDocTags,
-		Index:       obj.Index,
-		Validated:   false,
-		Recursive:   obj.Recursive,
-		Nullables:   obj.Nullables,
-	})
+  return MetadataObjectType_create(MetadataObjectType{
+    Name:        obj.Name,
+    Properties:  []*MetadataProperty{},
+    Description: obj.Description,
+    JsDocTags:   obj.JsDocTags,
+    Index:       obj.Index,
+    Validated:   false,
+    Recursive:   obj.Recursive,
+    Nullables:   obj.Nullables,
+  })
 }
 
 func (obj *MetadataObjectType) IsPlain(level ...int) bool {
-	lv := 0
-	if len(level) > 0 {
-		lv = level[0]
-	}
-	if obj.Recursive || len(obj.Properties) >= 10 {
-		return false
-	}
-	for _, property := range obj.Properties {
-		if property.Key.IsSoleLiteral() == false ||
-			property.Value.Size() != 1 ||
-			property.Value.IsRequired() == false ||
-			property.Value.Nullable {
-			return false
-		}
-		if len(property.Value.Atomics) == 1 {
-			continue
-		}
-		if lv < 1 && len(property.Value.Objects) == 1 && property.Value.Objects[0].Type.IsPlain(lv+1) {
-			continue
-		}
-		return false
-	}
-	return true
+  lv := 0
+  if len(level) > 0 {
+    lv = level[0]
+  }
+  if obj.Recursive || len(obj.Properties) >= 10 {
+    return false
+  }
+  for _, property := range obj.Properties {
+    if property.Key.IsSoleLiteral() == false ||
+      property.Value.Size() != 1 ||
+      property.Value.IsRequired() == false ||
+      property.Value.Nullable {
+      return false
+    }
+    if len(property.Value.Atomics) == 1 {
+      continue
+    }
+    if lv < 1 && len(property.Value.Objects) == 1 && property.Value.Objects[0].Type.IsPlain(lv+1) {
+      continue
+    }
+    return false
+  }
+  return true
 }
 
 func (obj *MetadataObjectType) IsLiteral() bool {
-	if obj.literal_ != nil {
-		return *obj.literal_
-	}
-	value := false
-	if obj.Recursive == false {
-		name := strings.ToValidUTF8(obj.Name, "__")
-		name = strings.ReplaceAll(name, "\uFFFD", "__")
-		value = name == "__type" ||
-			name == "__object" ||
-			strings.HasPrefix(name, "__type.") ||
-			strings.HasPrefix(name, "__object.") ||
-			strings.Contains(name, "readonly [")
-	}
-	obj.literal_ = &value
-	return value
+  if obj.literal_ != nil {
+    return *obj.literal_
+  }
+  value := false
+  if obj.Recursive == false {
+    name := strings.ToValidUTF8(obj.Name, "__")
+    name = strings.ReplaceAll(name, "\uFFFD", "__")
+    value = name == "__type" ||
+      name == "__object" ||
+      strings.HasPrefix(name, "__type.") ||
+      strings.HasPrefix(name, "__object.") ||
+      strings.Contains(name, "readonly [")
+  }
+  obj.literal_ = &value
+  return value
 }
 
 func (obj *MetadataObjectType) ToJSON() IMetadataSchema_IObjectType {
-	properties := make([]*IMetadataSchema_IProperty, 0, len(obj.Properties))
-	for _, property := range obj.Properties {
-		json := property.ToJSON()
-		properties = append(properties, &json)
-	}
-	return IMetadataSchema_IObjectType{
-		Name:        obj.Name,
-		Properties:  properties,
-		Description: obj.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
-		Index:       obj.Index,
-		Recursive:   obj.Recursive,
-		Nullables:   append([]bool{}, obj.Nullables...),
-	}
+  properties := make([]*IMetadataSchema_IProperty, 0, len(obj.Properties))
+  for _, property := range obj.Properties {
+    json := property.ToJSON()
+    properties = append(properties, &json)
+  }
+  return IMetadataSchema_IObjectType{
+    Name:        obj.Name,
+    Properties:  properties,
+    Description: obj.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+    Index:       obj.Index,
+    Recursive:   obj.Recursive,
+    Nullables:   append([]bool{}, obj.Nullables...),
+  }
 }
 
 func MetadataObjectType_intersects(x *MetadataObjectType, y *MetadataObjectType) bool {
-	for _, prop := range x.Properties {
-		for _, oppo := range y.Properties {
-			if prop.Key.GetName() == oppo.Key.GetName() {
-				return true
-			}
-		}
-	}
-	return false
+  for _, prop := range x.Properties {
+    for _, oppo := range y.Properties {
+      if prop.Key.GetName() == oppo.Key.GetName() {
+        return true
+      }
+    }
+  }
+  return false
 }
 
 func MetadataObjectType_covers(x *MetadataObjectType, y *MetadataObjectType) bool {
-	if len(x.Properties) < len(y.Properties) {
-		return false
-	}
-	for _, prop := range x.Properties {
-		found := false
-		for _, oppo := range y.Properties {
-			if prop.Key.GetName() == oppo.Key.GetName() {
-				found = true
-				break
-			}
-		}
-		if found == false {
-			return false
-		}
-	}
-	return true
+  if len(x.Properties) < len(y.Properties) {
+    return false
+  }
+  for _, prop := range x.Properties {
+    found := false
+    for _, oppo := range y.Properties {
+      if prop.Key.GetName() == oppo.Key.GetName() {
+        found = true
+        break
+      }
+    }
+    if found == false {
+      return false
+    }
+  }
+  return true
 }

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

@@ -3,44 +3,44 @@ package metadata
 import shimchecker "github.com/microsoft/typescript-go/shim/checker"
 
 type IMetadataSchema_IParameter struct {
-	Name        string
-	Type        *IMetadataSchema
-	Description *string
-	JsDocTags   []IJsDocTagInfo
+  Name        string
+  Type        *IMetadataSchema
+  Description *string
+  JsDocTags   []IJsDocTagInfo
 }
 
 type MetadataParameter struct {
-	Name        string
-	Type        *MetadataSchema
-	Description *string
-	JsDocTags   []IJsDocTagInfo
-	TsType      *shimchecker.Type
+  Name        string
+  Type        *MetadataSchema
+  Description *string
+  JsDocTags   []IJsDocTagInfo
+  TsType      *shimchecker.Type
 }
 
 func MetadataParameter_create(props MetadataParameter) *MetadataParameter {
-	return &MetadataParameter{
-		Name:        props.Name,
-		Type:        props.Type,
-		Description: props.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
-		TsType:      props.TsType,
-	}
+  return &MetadataParameter{
+    Name:        props.Name,
+    Type:        props.Type,
+    Description: props.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+    TsType:      props.TsType,
+  }
 }
 
 func MetadataParameter_from(json IMetadataSchema_IParameter, dict IMetadataDictionary) *MetadataParameter {
-	return MetadataParameter_create(MetadataParameter{
-		Name:        json.Name,
-		Type:        MetadataSchema_from(json.Type, dict),
-		Description: json.Description,
-		JsDocTags:   json.JsDocTags,
-	})
+  return MetadataParameter_create(MetadataParameter{
+    Name:        json.Name,
+    Type:        MetadataSchema_from(json.Type, dict),
+    Description: json.Description,
+    JsDocTags:   json.JsDocTags,
+  })
 }
 
 func (obj *MetadataParameter) ToJSON() IMetadataSchema_IParameter {
-	return IMetadataSchema_IParameter{
-		Name:        obj.Name,
-		Type:        obj.Type.ToJSON(),
-		Description: obj.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
-	}
+  return IMetadataSchema_IParameter{
+    Name:        obj.Name,
+    Type:        obj.Type.ToJSON(),
+    Description: obj.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+  }
 }

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

@@ -3,48 +3,48 @@ package metadata
 import nativeprotobuf "github.com/samchon/typia/packages/typia/native/core/schemas/protobuf"
 
 type IMetadataSchema_IProperty struct {
-	Key         *IMetadataSchema
-	Value       *IMetadataSchema
-	Description *string
-	JsDocTags   []IJsDocTagInfo
-	Mutability  *string
+  Key         *IMetadataSchema
+  Value       *IMetadataSchema
+  Description *string
+  JsDocTags   []IJsDocTagInfo
+  Mutability  *string
 }
 
 type MetadataProperty struct {
-	Key          *MetadataSchema
-	Value        *MetadataSchema
-	Description  *string
-	JsDocTags    []IJsDocTagInfo
-	Mutability   *string
-	Of_protobuf_ *nativeprotobuf.IProtobufProperty
+  Key          *MetadataSchema
+  Value        *MetadataSchema
+  Description  *string
+  JsDocTags    []IJsDocTagInfo
+  Mutability   *string
+  Of_protobuf_ *nativeprotobuf.IProtobufProperty
 }
 
 func MetadataProperty_create(props MetadataProperty) *MetadataProperty {
-	return &MetadataProperty{
-		Key:         props.Key,
-		Value:       props.Value,
-		Description: props.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
-		Mutability:  props.Mutability,
-	}
+  return &MetadataProperty{
+    Key:         props.Key,
+    Value:       props.Value,
+    Description: props.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, props.JsDocTags...),
+    Mutability:  props.Mutability,
+  }
 }
 
 func MetadataProperty_from(property IMetadataSchema_IProperty, dict IMetadataDictionary) *MetadataProperty {
-	return MetadataProperty_create(MetadataProperty{
-		Key:         MetadataSchema_from(property.Key, dict),
-		Value:       MetadataSchema_from(property.Value, dict),
-		Description: property.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, property.JsDocTags...),
-		Mutability:  property.Mutability,
-	})
+  return MetadataProperty_create(MetadataProperty{
+    Key:         MetadataSchema_from(property.Key, dict),
+    Value:       MetadataSchema_from(property.Value, dict),
+    Description: property.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, property.JsDocTags...),
+    Mutability:  property.Mutability,
+  })
 }
 
 func (obj *MetadataProperty) ToJSON() IMetadataSchema_IProperty {
-	return IMetadataSchema_IProperty{
-		Key:         obj.Key.ToJSON(),
-		Value:       obj.Value.ToJSON(),
-		Description: obj.Description,
-		JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
-		Mutability:  obj.Mutability,
-	}
+  return IMetadataSchema_IProperty{
+    Key:         obj.Key.ToJSON(),
+    Value:       obj.Value.ToJSON(),
+    Description: obj.Description,
+    JsDocTags:   append([]IJsDocTagInfo{}, obj.JsDocTags...),
+    Mutability:  obj.Mutability,
+  }
 }