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

package/native/core/factories/ProtobufFactory.go

@@ -1,15 +1,15 @@
 package factories
 
 import (
-	"fmt"
-	"math"
-	"sort"
-	"strings"
+  "fmt"
+  "math"
+  "sort"
+  "strings"
 
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-	nativeprotobuf "github.com/samchon/typia/packages/typia/native/core/schemas/protobuf"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeprotobuf "github.com/samchon/typia/packages/typia/native/core/schemas/protobuf"
 )
 
 type protobufFactoryNamespace struct{}
@@ -17,1052 +17,1052 @@ type protobufFactoryNamespace struct{}
 var ProtobufFactory = protobufFactoryNamespace{}
 
 type ProtobufFactory_IProps struct {
-	Method      string
-	Checker     *shimchecker.Checker
-	Transformer any
-	Components  *schemametadata.MetadataCollection
-	Type        *shimchecker.Type
+  Method      string
+  Checker     *shimchecker.Checker
+  Transformer any
+  Components  *schemametadata.MetadataCollection
+  Type        *shimchecker.Type
 }
 
 func (protobufFactoryNamespace) Metadata(props ProtobufFactory_IProps) *schemametadata.MetadataSchema {
-	result := MetadataFactory.Analyze(MetadataFactory_IProps{
-		Checker:     props.Checker,
-		Transformer: props.Transformer,
-		Options: MetadataFactory_IOptions{
-			Escape:   false,
-			Constant: true,
-			Absorb:   true,
-			Validate: protobufFactory_validate(),
-		},
-		Components: props.Components,
-		Type:       props.Type,
-	})
-	if result.Success == false {
-		panic(nativecontext.TransformerError_from(struct {
-			Code   string
-			Errors []nativecontext.TransformerError_MetadataFactory_IError
-		}{
-			Code:   "typia.protobuf." + props.Method,
-			Errors: protobufFactory_errors(result.Errors),
-		}))
-	}
-	return result.Data
+  result := MetadataFactory.Analyze(MetadataFactory_IProps{
+    Checker:     props.Checker,
+    Transformer: props.Transformer,
+    Options: MetadataFactory_IOptions{
+      Escape:   false,
+      Constant: true,
+      Absorb:   true,
+      Validate: protobufFactory_validate(),
+    },
+    Components: props.Components,
+    Type:       props.Type,
+  })
+  if result.Success == false {
+    panic(nativecontext.TransformerError_from(struct {
+      Code   string
+      Errors []nativecontext.TransformerError_MetadataFactory_IError
+    }{
+      Code:   "typia.protobuf." + props.Method,
+      Errors: protobufFactory_errors(result.Errors),
+    }))
+  }
+  return result.Data
 }
 
 func (protobufFactoryNamespace) EmplaceObject(object *schemametadata.MetadataObjectType) {
-	for _, property := range object.Properties {
-		protobufFactory_emplaceProperty(property)
-	}
-	properties := []*nativeprotobuf.IProtobufProperty{}
-	for _, property := range object.Properties {
-		if property.Of_protobuf_ != nil {
-			properties = append(properties, property.Of_protobuf_)
-		}
-	}
-	unique := map[int]bool{}
-	for _, property := range properties {
-		if property.Fixed == false {
-			continue
-		}
-		for _, union := range property.Union {
-			if index := protobufFactory_propertyIndex(union); index != nil {
-				unique[*index] = true
-			}
-		}
-	}
-	index := 1
-	for _, schema := range properties {
-		if schema.Fixed {
-			for _, union := range schema.Union {
-				if next := protobufFactory_propertyIndex(union); next != nil && *next >= index {
-					index = *next + 1
-				}
-			}
-			continue
-		}
-		for _, union := range schema.Union {
-			for unique[index] {
-				index++
-			}
-			protobufFactory_setPropertyIndex(union, index)
-			unique[index] = true
-		}
-		index++
-	}
+  for _, property := range object.Properties {
+    protobufFactory_emplaceProperty(property)
+  }
+  properties := []*nativeprotobuf.IProtobufProperty{}
+  for _, property := range object.Properties {
+    if property.Of_protobuf_ != nil {
+      properties = append(properties, property.Of_protobuf_)
+    }
+  }
+  unique := map[int]bool{}
+  for _, property := range properties {
+    if property.Fixed == false {
+      continue
+    }
+    for _, union := range property.Union {
+      if index := protobufFactory_propertyIndex(union); index != nil {
+        unique[*index] = true
+      }
+    }
+  }
+  index := 1
+  for _, schema := range properties {
+    if schema.Fixed {
+      for _, union := range schema.Union {
+        if next := protobufFactory_propertyIndex(union); next != nil && *next >= index {
+          index = *next + 1
+        }
+      }
+      continue
+    }
+    for _, union := range schema.Union {
+      for unique[index] {
+        index++
+      }
+      protobufFactory_setPropertyIndex(union, index)
+      unique[index] = true
+    }
+    index++
+  }
 }
 
 func protobufFactory_emplaceProperty(prop *schemametadata.MetadataProperty) {
-	union := []nativeprotobuf.IProtobufPropertyType{}
-	for _, native := range prop.Value.Natives {
-		if native.Name == "Uint8Array" {
-			union = append(union, &nativeprotobuf.IProtobufPropertyType_IByte{
-				IProtobufSchema_IByte: nativeprotobuf.IProtobufSchema_IByte{Type: "bytes"},
-				Index:                 protobufFactory_getSequence(protobufFactory_firstTagRow(native.Tags)),
-			})
-		}
-	}
-	union = append(union, protobufFactory_emplaceAtomic(prop.Value)...)
-	for _, array := range prop.Value.Arrays {
-		union = append(union, &nativeprotobuf.IProtobufPropertyType_IArray{
-			IProtobufSchema_IArray: nativeprotobuf.IProtobufSchema_IArray{
-				Type:  "array",
-				Array: array.Type,
-				Value: protobufFactory_emplaceSchema(array.Type.Value),
-			},
-			Index: protobufFactory_getSequence(protobufFactory_firstTagRow(array.Tags)),
-		})
-	}
-	for _, obj := range prop.Value.Objects {
-		if protobufFactory_isDynamicObject(obj.Type) {
-			union = append(union, &nativeprotobuf.IProtobufPropertyType_IMap{
-				IProtobufSchema_IMap: nativeprotobuf.IProtobufSchema_IMap{
-					Type:  "map",
-					Map:   obj.Type,
-					Key:   protobufFactory_emplaceSchema(obj.Type.Properties[0].Key),
-					Value: protobufFactory_emplaceSchema(obj.Type.Properties[0].Value),
-				},
-				Index: protobufFactory_getSequence(protobufFactory_firstTagRow(obj.Tags)),
-			})
-		} else {
-			union = append(union, &nativeprotobuf.IProtobufPropertyType_IObject{
-				IProtobufSchema_IObject: nativeprotobuf.IProtobufSchema_IObject{Type: "object", Object: obj.Type},
-				Index:                   protobufFactory_getSequence(protobufFactory_firstTagRow(obj.Tags)),
-			})
-		}
-	}
-	for _, entry := range prop.Value.Maps {
-		union = append(union, &nativeprotobuf.IProtobufPropertyType_IMap{
-			IProtobufSchema_IMap: nativeprotobuf.IProtobufSchema_IMap{
-				Type:  "map",
-				Map:   entry,
-				Key:   protobufFactory_emplaceSchema(entry.Key),
-				Value: protobufFactory_emplaceSchema(entry.Value),
-			},
-			Index: protobufFactory_getSequence(protobufFactory_firstTagRow(entry.Tags)),
-		})
-	}
-	fixed := true
-	for _, elem := range union {
-		if protobufFactory_propertyIndex(elem) == nil {
-			fixed = false
-			break
-		}
-	}
-	prop.Of_protobuf_ = &nativeprotobuf.IProtobufProperty{
-		Union: union,
-		Fixed: fixed,
-	}
+  union := []nativeprotobuf.IProtobufPropertyType{}
+  for _, native := range prop.Value.Natives {
+    if native.Name == "Uint8Array" {
+      union = append(union, &nativeprotobuf.IProtobufPropertyType_IByte{
+        IProtobufSchema_IByte: nativeprotobuf.IProtobufSchema_IByte{Type: "bytes"},
+        Index:                 protobufFactory_getSequence(protobufFactory_firstTagRow(native.Tags)),
+      })
+    }
+  }
+  union = append(union, protobufFactory_emplaceAtomic(prop.Value)...)
+  for _, array := range prop.Value.Arrays {
+    union = append(union, &nativeprotobuf.IProtobufPropertyType_IArray{
+      IProtobufSchema_IArray: nativeprotobuf.IProtobufSchema_IArray{
+        Type:  "array",
+        Array: array.Type,
+        Value: protobufFactory_emplaceSchema(array.Type.Value),
+      },
+      Index: protobufFactory_getSequence(protobufFactory_firstTagRow(array.Tags)),
+    })
+  }
+  for _, obj := range prop.Value.Objects {
+    if protobufFactory_isDynamicObject(obj.Type) {
+      union = append(union, &nativeprotobuf.IProtobufPropertyType_IMap{
+        IProtobufSchema_IMap: nativeprotobuf.IProtobufSchema_IMap{
+          Type:  "map",
+          Map:   obj.Type,
+          Key:   protobufFactory_emplaceSchema(obj.Type.Properties[0].Key),
+          Value: protobufFactory_emplaceSchema(obj.Type.Properties[0].Value),
+        },
+        Index: protobufFactory_getSequence(protobufFactory_firstTagRow(obj.Tags)),
+      })
+    } else {
+      union = append(union, &nativeprotobuf.IProtobufPropertyType_IObject{
+        IProtobufSchema_IObject: nativeprotobuf.IProtobufSchema_IObject{Type: "object", Object: obj.Type},
+        Index:                   protobufFactory_getSequence(protobufFactory_firstTagRow(obj.Tags)),
+      })
+    }
+  }
+  for _, entry := range prop.Value.Maps {
+    union = append(union, &nativeprotobuf.IProtobufPropertyType_IMap{
+      IProtobufSchema_IMap: nativeprotobuf.IProtobufSchema_IMap{
+        Type:  "map",
+        Map:   entry,
+        Key:   protobufFactory_emplaceSchema(entry.Key),
+        Value: protobufFactory_emplaceSchema(entry.Value),
+      },
+      Index: protobufFactory_getSequence(protobufFactory_firstTagRow(entry.Tags)),
+    })
+  }
+  fixed := true
+  for _, elem := range union {
+    if protobufFactory_propertyIndex(elem) == nil {
+      fixed = false
+      break
+    }
+  }
+  prop.Of_protobuf_ = &nativeprotobuf.IProtobufProperty{
+    Union: union,
+    Fixed: fixed,
+  }
 }
 
 func protobufFactory_emplaceSchema(metadata *schemametadata.MetadataSchema) nativeprotobuf.IProtobufSchema {
-	for _, native := range metadata.Natives {
-		if native.Name == "Uint8Array" {
-			return nativeprotobuf.IProtobufSchema_IByte{Type: "bytes"}
-		}
-	}
-	atomic := protobufFactory_emplaceAtomic(metadata)
-	if len(atomic) != 0 {
-		return atomic[0]
-	}
-	for _, array := range metadata.Arrays {
-		return nativeprotobuf.IProtobufSchema_IArray{
-			Type:  "array",
-			Array: array.Type,
-			Value: protobufFactory_emplaceSchema(array.Type.Value),
-		}
-	}
-	for _, obj := range metadata.Objects {
-		if protobufFactory_isDynamicObject(obj.Type) {
-			return nativeprotobuf.IProtobufSchema_IMap{
-				Type:  "map",
-				Map:   obj.Type,
-				Key:   protobufFactory_emplaceSchema(obj.Type.Properties[0].Key),
-				Value: protobufFactory_emplaceSchema(obj.Type.Properties[0].Value),
-			}
-		}
-		return nativeprotobuf.IProtobufSchema_IObject{Type: "object", Object: obj.Type}
-	}
-	for _, entry := range metadata.Maps {
-		return nativeprotobuf.IProtobufSchema_IMap{
-			Type:  "map",
-			Map:   entry,
-			Key:   protobufFactory_emplaceSchema(entry.Key),
-			Value: protobufFactory_emplaceSchema(entry.Value),
-		}
-	}
-	panic("Error on ProtobufFactory.emplaceSchema(): any type detected.")
+  for _, native := range metadata.Natives {
+    if native.Name == "Uint8Array" {
+      return nativeprotobuf.IProtobufSchema_IByte{Type: "bytes"}
+    }
+  }
+  atomic := protobufFactory_emplaceAtomic(metadata)
+  if len(atomic) != 0 {
+    return atomic[0]
+  }
+  for _, array := range metadata.Arrays {
+    return nativeprotobuf.IProtobufSchema_IArray{
+      Type:  "array",
+      Array: array.Type,
+      Value: protobufFactory_emplaceSchema(array.Type.Value),
+    }
+  }
+  for _, obj := range metadata.Objects {
+    if protobufFactory_isDynamicObject(obj.Type) {
+      return nativeprotobuf.IProtobufSchema_IMap{
+        Type:  "map",
+        Map:   obj.Type,
+        Key:   protobufFactory_emplaceSchema(obj.Type.Properties[0].Key),
+        Value: protobufFactory_emplaceSchema(obj.Type.Properties[0].Value),
+      }
+    }
+    return nativeprotobuf.IProtobufSchema_IObject{Type: "object", Object: obj.Type}
+  }
+  for _, entry := range metadata.Maps {
+    return nativeprotobuf.IProtobufSchema_IMap{
+      Type:  "map",
+      Map:   entry,
+      Key:   protobufFactory_emplaceSchema(entry.Key),
+      Value: protobufFactory_emplaceSchema(entry.Value),
+    }
+  }
+  panic("Error on ProtobufFactory.emplaceSchema(): any type detected.")
 }
 
 func protobufFactory_emplaceAtomic(meta *schemametadata.MetadataSchema) []nativeprotobuf.IProtobufPropertyType {
-	values := map[string]nativeprotobuf.IProtobufPropertyType{}
-	for _, constant := range meta.Constants {
-		if constant.Type == "boolean" {
-			values["bool"] = &nativeprotobuf.IProtobufPropertyType_IBoolean{
-				IProtobufSchema_IBoolean: nativeprotobuf.IProtobufSchema_IBoolean{Type: "bool"},
-				Index:                    protobufFactory_getSequence(protobufFactory_firstTags(constant.Values)),
-			}
-		} else if constant.Type == "bigint" {
-			init := protobufFactory_getBigintType(protobufFactory_constantValues(constant.Values))
-			for _, value := range constant.Values {
-				protobufFactory_emplaceBigint(values, value.Tags, init)
-			}
-		} else if constant.Type == "number" {
-			init := protobufFactory_getNumberType(protobufFactory_constantValues(constant.Values))
-			for _, value := range constant.Values {
-				protobufFactory_emplaceNumber(values, value.Tags, init)
-			}
-		} else if constant.Type == "string" {
-			values["string"] = &nativeprotobuf.IProtobufPropertyType_IString{
-				IProtobufSchema_IString: nativeprotobuf.IProtobufSchema_IString{Type: "string"},
-				Index:                   protobufFactory_getSequence(protobufFactory_firstTags(constant.Values)),
-			}
-		}
-	}
-	if len(meta.Templates) != 0 {
-		values["string"] = &nativeprotobuf.IProtobufPropertyType_IString{
-			IProtobufSchema_IString: nativeprotobuf.IProtobufSchema_IString{Type: "string"},
-			Index:                   protobufFactory_getSequence(protobufFactory_firstTagRow(meta.Templates[0].Tags)),
-		}
-	}
-	for _, atomic := range meta.Atomics {
-		if atomic.Type == "boolean" {
-			values["bool"] = &nativeprotobuf.IProtobufPropertyType_IBoolean{
-				IProtobufSchema_IBoolean: nativeprotobuf.IProtobufSchema_IBoolean{Type: "bool"},
-				Index:                    protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags)),
-			}
-		} else if atomic.Type == "bigint" {
-			protobufFactory_emplaceBigint(values, atomic.Tags, "int64")
-		} else if atomic.Type == "number" {
-			protobufFactory_emplaceNumber(values, atomic.Tags, "double")
-		} else if atomic.Type == "string" {
-			values["string"] = &nativeprotobuf.IProtobufPropertyType_IString{
-				IProtobufSchema_IString: nativeprotobuf.IProtobufSchema_IString{Type: "string"},
-				Index:                   protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags)),
-			}
-		}
-	}
-	keys := make([]string, 0, len(values))
-	for key := range values {
-		keys = append(keys, key)
-	}
-	sort.Slice(keys, func(i, j int) bool {
-		return protobufFactory_compare(keys[i], keys[j]) < 0
-	})
-	output := make([]nativeprotobuf.IProtobufPropertyType, 0, len(keys))
-	for _, key := range keys {
-		output = append(output, values[key])
-	}
-	return output
+  values := map[string]nativeprotobuf.IProtobufPropertyType{}
+  for _, constant := range meta.Constants {
+    if constant.Type == "boolean" {
+      values["bool"] = &nativeprotobuf.IProtobufPropertyType_IBoolean{
+        IProtobufSchema_IBoolean: nativeprotobuf.IProtobufSchema_IBoolean{Type: "bool"},
+        Index:                    protobufFactory_getSequence(protobufFactory_firstTags(constant.Values)),
+      }
+    } else if constant.Type == "bigint" {
+      init := protobufFactory_getBigintType(protobufFactory_constantValues(constant.Values))
+      for _, value := range constant.Values {
+        protobufFactory_emplaceBigint(values, value.Tags, init)
+      }
+    } else if constant.Type == "number" {
+      init := protobufFactory_getNumberType(protobufFactory_constantValues(constant.Values))
+      for _, value := range constant.Values {
+        protobufFactory_emplaceNumber(values, value.Tags, init)
+      }
+    } else if constant.Type == "string" {
+      values["string"] = &nativeprotobuf.IProtobufPropertyType_IString{
+        IProtobufSchema_IString: nativeprotobuf.IProtobufSchema_IString{Type: "string"},
+        Index:                   protobufFactory_getSequence(protobufFactory_firstTags(constant.Values)),
+      }
+    }
+  }
+  if len(meta.Templates) != 0 {
+    values["string"] = &nativeprotobuf.IProtobufPropertyType_IString{
+      IProtobufSchema_IString: nativeprotobuf.IProtobufSchema_IString{Type: "string"},
+      Index:                   protobufFactory_getSequence(protobufFactory_firstTagRow(meta.Templates[0].Tags)),
+    }
+  }
+  for _, atomic := range meta.Atomics {
+    if atomic.Type == "boolean" {
+      values["bool"] = &nativeprotobuf.IProtobufPropertyType_IBoolean{
+        IProtobufSchema_IBoolean: nativeprotobuf.IProtobufSchema_IBoolean{Type: "bool"},
+        Index:                    protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags)),
+      }
+    } else if atomic.Type == "bigint" {
+      protobufFactory_emplaceBigint(values, atomic.Tags, "int64")
+    } else if atomic.Type == "number" {
+      protobufFactory_emplaceNumber(values, atomic.Tags, "double")
+    } else if atomic.Type == "string" {
+      values["string"] = &nativeprotobuf.IProtobufPropertyType_IString{
+        IProtobufSchema_IString: nativeprotobuf.IProtobufSchema_IString{Type: "string"},
+        Index:                   protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags)),
+      }
+    }
+  }
+  keys := make([]string, 0, len(values))
+  for key := range values {
+    keys = append(keys, key)
+  }
+  sort.Slice(keys, func(i, j int) bool {
+    return protobufFactory_compare(keys[i], keys[j]) < 0
+  })
+  output := make([]nativeprotobuf.IProtobufPropertyType, 0, len(keys))
+  for _, key := range keys {
+    output = append(output, values[key])
+  }
+  return output
 }
 
 func protobufFactory_emplaceBigint(output map[string]nativeprotobuf.IProtobufPropertyType, tags [][]schemametadata.IMetadataTypeTag, init string) {
-	if len(tags) == 0 {
-		output[init] = &nativeprotobuf.IProtobufPropertyType_IBigint{
-			IProtobufSchema_IBigint: nativeprotobuf.IProtobufSchema_IBigint{Type: "bigint", Name: init},
-			Index:                   nil,
-		}
-		return
-	}
-	for _, row := range tags {
-		value := init
-		for _, tag := range row {
-			if tag.Kind == "type" && (tag.Value == "int64" || tag.Value == "uint64") {
-				value = fmt.Sprint(tag.Value)
-				break
-			}
-		}
-		output[init] = &nativeprotobuf.IProtobufPropertyType_IBigint{
-			IProtobufSchema_IBigint: nativeprotobuf.IProtobufSchema_IBigint{Type: "bigint", Name: value},
-			Index:                   protobufFactory_getSequence(row),
-		}
-	}
+  if len(tags) == 0 {
+    output[init] = &nativeprotobuf.IProtobufPropertyType_IBigint{
+      IProtobufSchema_IBigint: nativeprotobuf.IProtobufSchema_IBigint{Type: "bigint", Name: init},
+      Index:                   nil,
+    }
+    return
+  }
+  for _, row := range tags {
+    value := init
+    for _, tag := range row {
+      if tag.Kind == "type" && (tag.Value == "int64" || tag.Value == "uint64") {
+        value = fmt.Sprint(tag.Value)
+        break
+      }
+    }
+    output[init] = &nativeprotobuf.IProtobufPropertyType_IBigint{
+      IProtobufSchema_IBigint: nativeprotobuf.IProtobufSchema_IBigint{Type: "bigint", Name: value},
+      Index:                   protobufFactory_getSequence(row),
+    }
+  }
 }
 
 func protobufFactory_emplaceNumber(output map[string]nativeprotobuf.IProtobufPropertyType, tags [][]schemametadata.IMetadataTypeTag, init string) {
-	if len(tags) == 0 {
-		output[init] = &nativeprotobuf.IProtobufPropertyType_INumber{
-			IProtobufSchema_INumber: nativeprotobuf.IProtobufSchema_INumber{Type: "number", Name: init},
-			Index:                   nil,
-		}
-		return
-	}
-	for _, row := range tags {
-		value := init
-		for _, tag := range row {
-			if tag.Kind != "type" {
-				continue
-			}
-			str := fmt.Sprint(tag.Value)
-			if str == "int32" || str == "uint32" || str == "int64" || str == "uint64" || str == "float" || str == "double" {
-				value = str
-				break
-			}
-		}
-		output[value] = &nativeprotobuf.IProtobufPropertyType_INumber{
-			IProtobufSchema_INumber: nativeprotobuf.IProtobufSchema_INumber{Type: "number", Name: value},
-			Index:                   protobufFactory_getSequence(row),
-		}
-	}
+  if len(tags) == 0 {
+    output[init] = &nativeprotobuf.IProtobufPropertyType_INumber{
+      IProtobufSchema_INumber: nativeprotobuf.IProtobufSchema_INumber{Type: "number", Name: init},
+      Index:                   nil,
+    }
+    return
+  }
+  for _, row := range tags {
+    value := init
+    for _, tag := range row {
+      if tag.Kind != "type" {
+        continue
+      }
+      str := fmt.Sprint(tag.Value)
+      if str == "int32" || str == "uint32" || str == "int64" || str == "uint64" || str == "float" || str == "double" {
+        value = str
+        break
+      }
+    }
+    output[value] = &nativeprotobuf.IProtobufPropertyType_INumber{
+      IProtobufSchema_INumber: nativeprotobuf.IProtobufSchema_INumber{Type: "number", Name: value},
+      Index:                   protobufFactory_getSequence(row),
+    }
+  }
 }
 
 func protobufFactory_validate() MetadataFactory_Validator {
-	visited := map[*schemametadata.MetadataObjectType]bool{}
-	return func(props struct {
-		Metadata *schemametadata.MetadataSchema
-		Explore  MetadataFactory_IExplore
-		Top      *schemametadata.MetadataSchema
-	}) []string {
-		errors := []string{}
-		insert := func(msg string) { errors = append(errors, msg) }
-		if props.Explore.Top == true {
-			onlyObject := props.Metadata.Size() == 1 &&
-				len(props.Metadata.Objects) == 1 &&
-				props.Metadata.IsRequired() == true &&
-				props.Metadata.Nullable == false
-			if onlyObject && len(props.Metadata.Objects) != 0 {
-				for _, property := range props.Metadata.Objects[0].Type.Properties {
-					if property.Key.IsSoleLiteral() == false {
-						onlyObject = false
-						break
-					}
-				}
-			}
-			if onlyObject == false {
-				insert("target type must be a sole and static object type")
-			}
-		}
-		for _, obj := range props.Metadata.Objects {
-			if visited[obj.Type] {
-				continue
-			}
-			visited[obj.Type] = true
-			protobufFactory_validateObject(obj.Type, &errors)
-			func() {
-				defer func() { _ = recover() }()
-				ProtobufFactory.EmplaceObject(obj.Type)
-			}()
-		}
-		noSupport := func(msg string) { insert("does not support " + msg) }
-		if props.Metadata.Any {
-			noSupport("any type")
-		}
-		if len(props.Metadata.Functions) != 0 {
-			noSupport("functional type")
-		}
-		if len(props.Metadata.Tuples) != 0 {
-			noSupport("tuple type")
-		}
-		if len(props.Metadata.Sets) != 0 {
-			noSupport("Set type")
-		}
-		for _, native := range props.Metadata.Natives {
-			if native.Name == "Uint8Array" {
-				continue
-			}
-			if instead, ok := protobufFactory_BANNED_NATIVE_TYPES[native.Name]; ok {
-				noSupport(native.Name + " type. Use " + instead + " type instead.")
-			} else {
-				noSupport(native.Name + " type")
-			}
-		}
-		if len(props.Metadata.Atomics) != 0 {
-			numbers := protobufFactory_getNumbers(props.Metadata)
-			bigints := protobufFactory_getBigints(props.Metadata)
-			for _, typ := range []string{"int64", "uint64"} {
-				if _, ok := numbers[typ]; ok {
-					if _, found := bigints[typ]; found {
-						insert("tags.Type<\"" + typ + "\"> cannot be used in both number and bigint types. Recommend to remove from number type")
-					}
-				}
-			}
-		}
-		protobufFactory_validateShape(props.Metadata, noSupport)
-		return errors
-	}
+  visited := map[*schemametadata.MetadataObjectType]bool{}
+  return func(props struct {
+    Metadata *schemametadata.MetadataSchema
+    Explore  MetadataFactory_IExplore
+    Top      *schemametadata.MetadataSchema
+  }) []string {
+    errors := []string{}
+    insert := func(msg string) { errors = append(errors, msg) }
+    if props.Explore.Top == true {
+      onlyObject := props.Metadata.Size() == 1 &&
+        len(props.Metadata.Objects) == 1 &&
+        props.Metadata.IsRequired() == true &&
+        props.Metadata.Nullable == false
+      if onlyObject && len(props.Metadata.Objects) != 0 {
+        for _, property := range props.Metadata.Objects[0].Type.Properties {
+          if property.Key.IsSoleLiteral() == false {
+            onlyObject = false
+            break
+          }
+        }
+      }
+      if onlyObject == false {
+        insert("target type must be a sole and static object type")
+      }
+    }
+    for _, obj := range props.Metadata.Objects {
+      if visited[obj.Type] {
+        continue
+      }
+      visited[obj.Type] = true
+      protobufFactory_validateObject(obj.Type, &errors)
+      func() {
+        defer func() { _ = recover() }()
+        ProtobufFactory.EmplaceObject(obj.Type)
+      }()
+    }
+    noSupport := func(msg string) { insert("does not support " + msg) }
+    if props.Metadata.Any {
+      noSupport("any type")
+    }
+    if len(props.Metadata.Functions) != 0 {
+      noSupport("functional type")
+    }
+    if len(props.Metadata.Tuples) != 0 {
+      noSupport("tuple type")
+    }
+    if len(props.Metadata.Sets) != 0 {
+      noSupport("Set type")
+    }
+    for _, native := range props.Metadata.Natives {
+      if native.Name == "Uint8Array" {
+        continue
+      }
+      if instead, ok := protobufFactory_BANNED_NATIVE_TYPES[native.Name]; ok {
+        noSupport(native.Name + " type. Use " + instead + " type instead.")
+      } else {
+        noSupport(native.Name + " type")
+      }
+    }
+    if len(props.Metadata.Atomics) != 0 {
+      numbers := protobufFactory_getNumbers(props.Metadata)
+      bigints := protobufFactory_getBigints(props.Metadata)
+      for _, typ := range []string{"int64", "uint64"} {
+        if _, ok := numbers[typ]; ok {
+          if _, found := bigints[typ]; found {
+            insert("tags.Type<\"" + typ + "\"> cannot be used in both number and bigint types. Recommend to remove from number type")
+          }
+        }
+      }
+    }
+    protobufFactory_validateShape(props.Metadata, noSupport)
+    return errors
+  }
 }
 
 func protobufFactory_validateShape(metadata *schemametadata.MetadataSchema, noSupport func(string)) {
-	if len(metadata.Arrays) != 0 {
-		for _, array := range metadata.Arrays {
-			if len(array.Type.Value.Arrays) != 0 {
-				noSupport("over two dimensional array type")
-				break
-			}
-		}
-		for _, array := range metadata.Arrays {
-			if array.Type.Value.IsRequired() == false || array.Type.Value.Nullable {
-				noSupport("optional type in array")
-				break
-			}
-		}
-		for _, array := range metadata.Arrays {
-			if array.Type.Value.Size() > 1 && len(array.Type.Value.Constants) != 1 {
-				noSupport("union type in array")
-				break
-			}
-		}
-		for _, array := range metadata.Arrays {
-			if len(array.Type.Value.Maps) != 0 {
-				noSupport("dynamic object in array")
-				break
-			}
-			for _, obj := range array.Type.Value.Objects {
-				if protobufFactory_isStaticObject(obj.Type) == false {
-					noSupport("dynamic object in array")
-					break
-				}
-			}
-		}
-		if metadata.Size() > 1 {
-			noSupport("union type with array type")
-		}
-	}
-	if len(metadata.Objects) != 0 {
-		for _, obj := range metadata.Objects {
-			if len(obj.Type.Properties) == 0 {
-				noSupport("empty object type")
-				break
-			}
-		}
-		for _, obj := range metadata.Objects {
-			dynamic := 0
-			static := 0
-			for _, property := range obj.Type.Properties {
-				if property.Key.IsSoleLiteral() {
-					static++
-				} else {
-					dynamic++
-				}
-			}
-			if dynamic > 1 {
-				noSupport("object type with multiple dynamic key typed properties. Keep only one.")
-			}
-			if static != 0 && dynamic != 0 {
-				noSupport("object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.")
-			}
-		}
-		if protobufFactory_isDynamicObject(metadata.Objects[0].Type) {
-			for _, property := range metadata.Objects[0].Type.Properties {
-				if len(property.Value.Arrays) != 0 {
-					noSupport("dynamic object with array value type")
-					break
-				}
-				if protobufFactory_isUnion(property.Value) {
-					noSupport("union type in dynamic property")
-					break
-				}
-			}
-			if metadata.Size() > 1 {
-				noSupport("union type with dynamic object type")
-			}
-		}
-	}
-	if len(metadata.Maps) != 0 {
-		for _, entry := range metadata.Maps {
-			if protobufFactory_isUnion(entry.Key) {
-				noSupport("union key typed map")
-			}
-			if len(protobufFactory_getAtomics(entry.Key)) != 1 {
-				noSupport("non-atomic key typed map")
-			}
-			if entry.Key.IsRequired() == false || entry.Key.Nullable {
-				noSupport("optional key typed map")
-			}
-			if len(entry.Value.Arrays) != 0 {
-				noSupport("map type with array value type")
-			}
-			if protobufFactory_isUnion(entry.Value) {
-				noSupport("union type in map value type")
-			}
-		}
-		if metadata.Size() > 1 {
-			noSupport("union type with map type")
-		}
-	}
+  if len(metadata.Arrays) != 0 {
+    for _, array := range metadata.Arrays {
+      if len(array.Type.Value.Arrays) != 0 {
+        noSupport("over two dimensional array type")
+        break
+      }
+    }
+    for _, array := range metadata.Arrays {
+      if array.Type.Value.IsRequired() == false || array.Type.Value.Nullable {
+        noSupport("optional type in array")
+        break
+      }
+    }
+    for _, array := range metadata.Arrays {
+      if array.Type.Value.Size() > 1 && len(array.Type.Value.Constants) != 1 {
+        noSupport("union type in array")
+        break
+      }
+    }
+    for _, array := range metadata.Arrays {
+      if len(array.Type.Value.Maps) != 0 {
+        noSupport("dynamic object in array")
+        break
+      }
+      for _, obj := range array.Type.Value.Objects {
+        if protobufFactory_isStaticObject(obj.Type) == false {
+          noSupport("dynamic object in array")
+          break
+        }
+      }
+    }
+    if metadata.Size() > 1 {
+      noSupport("union type with array type")
+    }
+  }
+  if len(metadata.Objects) != 0 {
+    for _, obj := range metadata.Objects {
+      if len(obj.Type.Properties) == 0 {
+        noSupport("empty object type")
+        break
+      }
+    }
+    for _, obj := range metadata.Objects {
+      dynamic := 0
+      static := 0
+      for _, property := range obj.Type.Properties {
+        if property.Key.IsSoleLiteral() {
+          static++
+        } else {
+          dynamic++
+        }
+      }
+      if dynamic > 1 {
+        noSupport("object type with multiple dynamic key typed properties. Keep only one.")
+      }
+      if static != 0 && dynamic != 0 {
+        noSupport("object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.")
+      }
+    }
+    if protobufFactory_isDynamicObject(metadata.Objects[0].Type) {
+      for _, property := range metadata.Objects[0].Type.Properties {
+        if len(property.Value.Arrays) != 0 {
+          noSupport("dynamic object with array value type")
+          break
+        }
+        if protobufFactory_isUnion(property.Value) {
+          noSupport("union type in dynamic property")
+          break
+        }
+      }
+      if metadata.Size() > 1 {
+        noSupport("union type with dynamic object type")
+      }
+    }
+  }
+  if len(metadata.Maps) != 0 {
+    for _, entry := range metadata.Maps {
+      if protobufFactory_isUnion(entry.Key) {
+        noSupport("union key typed map")
+      }
+      if len(protobufFactory_getAtomics(entry.Key)) != 1 {
+        noSupport("non-atomic key typed map")
+      }
+      if entry.Key.IsRequired() == false || entry.Key.Nullable {
+        noSupport("optional key typed map")
+      }
+      if len(entry.Value.Arrays) != 0 {
+        noSupport("map type with array value type")
+      }
+      if protobufFactory_isUnion(entry.Value) {
+        noSupport("union type in map value type")
+      }
+    }
+    if metadata.Size() > 1 {
+      noSupport("union type with map type")
+    }
+  }
 }
 
 func protobufFactory_validateObject(object *schemametadata.MetadataObjectType, errors *[]string) {
-	for _, property := range object.Properties {
-		protobufFactory_validateProperty(property.Value, errors)
-	}
-	entire := map[int]string{}
-	for _, property := range object.Properties {
-		local := map[int]bool{}
-		tagger := func(matrix [][]schemametadata.IMetadataTypeTag) {
-			for _, tags := range matrix {
-				if value := protobufFactory_getSequence(tags); value != nil {
-					local[*value] = true
-				}
-			}
-		}
-		for _, c := range property.Value.Constants {
-			for _, v := range c.Values {
-				tagger(v.Tags)
-			}
-		}
-		for _, a := range property.Value.Atomics {
-			tagger(a.Tags)
-		}
-		for _, t := range property.Value.Templates {
-			tagger(t.Tags)
-		}
-		for _, o := range property.Value.Objects {
-			tagger(o.Tags)
-		}
-		for _, a := range property.Value.Arrays {
-			tagger(a.Tags)
-		}
-		for sequence := range local {
-			name := ""
-			if property.Key.GetSoleLiteral() != nil {
-				name = *property.Key.GetSoleLiteral()
-			}
-			if prev, ok := entire[sequence]; ok {
-				*errors = append(*errors, fmt.Sprintf("The Sequence<%d> tag is duplicated in two properties (%q and %q)", sequence, prev, name))
-			} else {
-				entire[sequence] = name
-			}
-		}
-	}
+  for _, property := range object.Properties {
+    protobufFactory_validateProperty(property.Value, errors)
+  }
+  entire := map[int]string{}
+  for _, property := range object.Properties {
+    local := map[int]bool{}
+    tagger := func(matrix [][]schemametadata.IMetadataTypeTag) {
+      for _, tags := range matrix {
+        if value := protobufFactory_getSequence(tags); value != nil {
+          local[*value] = true
+        }
+      }
+    }
+    for _, c := range property.Value.Constants {
+      for _, v := range c.Values {
+        tagger(v.Tags)
+      }
+    }
+    for _, a := range property.Value.Atomics {
+      tagger(a.Tags)
+    }
+    for _, t := range property.Value.Templates {
+      tagger(t.Tags)
+    }
+    for _, o := range property.Value.Objects {
+      tagger(o.Tags)
+    }
+    for _, a := range property.Value.Arrays {
+      tagger(a.Tags)
+    }
+    for sequence := range local {
+      name := ""
+      if property.Key.GetSoleLiteral() != nil {
+        name = *property.Key.GetSoleLiteral()
+      }
+      if prev, ok := entire[sequence]; ok {
+        *errors = append(*errors, fmt.Sprintf("The Sequence<%d> tag is duplicated in two properties (%q and %q)", sequence, prev, name))
+      } else {
+        entire[sequence] = name
+      }
+    }
+  }
 }
 
 func protobufFactory_validateProperty(metadata *schemametadata.MetadataSchema, errors *[]string) {
-	sequences := map[int]bool{}
-	add := func(value int) bool {
-		if sequences[value] {
-			return false
-		}
-		sequences[value] = true
-		return true
-	}
-	protobufFactory_validateBooleanSequence(metadata, errors, add)
-	protobufFactory_validateNumericSequences(metadata, errors, add, "bigint", "int64", protobufFactory_BIGINT_TYPES)
-	protobufFactory_validateNumericSequences(metadata, errors, add, "number", "double", protobufFactory_NUMBER_TYPES)
-	protobufFactory_validateStringSequence(metadata, errors, add)
-	for _, array := range metadata.Arrays {
-		protobufFactory_validateInstanceSequence("array", array.Tags, errors, add)
-	}
-	for _, object := range metadata.Objects {
-		protobufFactory_validateInstanceSequence("object", object.Tags, errors, add)
-	}
-	for _, entry := range metadata.Maps {
-		protobufFactory_validateInstanceSequence("map", entry.Tags, errors, add)
-	}
-	for _, native := range metadata.Natives {
-		if native.Name == "Uint8Array" {
-			protobufFactory_validateInstanceSequence("Uint8Array", native.Tags, errors, add)
-		}
-	}
+  sequences := map[int]bool{}
+  add := func(value int) bool {
+    if sequences[value] {
+      return false
+    }
+    sequences[value] = true
+    return true
+  }
+  protobufFactory_validateBooleanSequence(metadata, errors, add)
+  protobufFactory_validateNumericSequences(metadata, errors, add, "bigint", "int64", protobufFactory_BIGINT_TYPES)
+  protobufFactory_validateNumericSequences(metadata, errors, add, "number", "double", protobufFactory_NUMBER_TYPES)
+  protobufFactory_validateStringSequence(metadata, errors, add)
+  for _, array := range metadata.Arrays {
+    protobufFactory_validateInstanceSequence("array", array.Tags, errors, add)
+  }
+  for _, object := range metadata.Objects {
+    protobufFactory_validateInstanceSequence("object", object.Tags, errors, add)
+  }
+  for _, entry := range metadata.Maps {
+    protobufFactory_validateInstanceSequence("map", entry.Tags, errors, add)
+  }
+  for _, native := range metadata.Natives {
+    if native.Name == "Uint8Array" {
+      protobufFactory_validateInstanceSequence("Uint8Array", native.Tags, errors, add)
+    }
+  }
 }
 
 func protobufFactory_validateBooleanSequence(metadata *schemametadata.MetadataSchema, errors *[]string, add func(int) bool) {
-	unique, expected, actual := map[int]bool{}, 0, 0
-	emplace := func(matrix [][]schemametadata.IMetadataTypeTag) {
-		for _, tags := range matrix {
-			for _, tag := range tags {
-				if sequence := protobufFactory_getSequence([]schemametadata.IMetadataTypeTag{tag}); sequence != nil {
-					unique[*sequence] = true
-					actual++
-				}
-				expected++
-			}
-		}
-	}
-	for _, atomic := range metadata.Atomics {
-		if atomic.Type == "boolean" {
-			emplace(atomic.Tags)
-		}
-	}
-	for _, constant := range metadata.Constants {
-		if constant.Type == "boolean" {
-			for _, value := range constant.Values {
-				emplace(value.Tags)
-			}
-		}
-	}
-	protobufFactory_validateUniqueSequence("boolean type", unique, expected, actual, errors, add)
+  unique, expected, actual := map[int]bool{}, 0, 0
+  emplace := func(matrix [][]schemametadata.IMetadataTypeTag) {
+    for _, tags := range matrix {
+      for _, tag := range tags {
+        if sequence := protobufFactory_getSequence([]schemametadata.IMetadataTypeTag{tag}); sequence != nil {
+          unique[*sequence] = true
+          actual++
+        }
+        expected++
+      }
+    }
+  }
+  for _, atomic := range metadata.Atomics {
+    if atomic.Type == "boolean" {
+      emplace(atomic.Tags)
+    }
+  }
+  for _, constant := range metadata.Constants {
+    if constant.Type == "boolean" {
+      for _, value := range constant.Values {
+        emplace(value.Tags)
+      }
+    }
+  }
+  protobufFactory_validateUniqueSequence("boolean type", unique, expected, actual, errors, add)
 }
 
 func protobufFactory_validateNumericSequences(metadata *schemametadata.MetadataSchema, errors *[]string, add func(int) bool, typ string, def string, categories map[string]bool) {
-	foundCategories := map[string]bool{}
-	getType := func(tags []schemametadata.IMetadataTypeTag) string {
-		for _, tag := range tags {
-			if tag.Kind == "type" && categories[fmt.Sprint(tag.Value)] {
-				return fmt.Sprint(tag.Value)
-			}
-		}
-		return def
-	}
-	for _, atomic := range metadata.Atomics {
-		if atomic.Type == typ {
-			for _, tags := range atomic.Tags {
-				foundCategories[getType(tags)] = true
-			}
-		}
-	}
-	for _, constant := range metadata.Constants {
-		if constant.Type == typ {
-			for _, value := range constant.Values {
-				for _, tags := range value.Tags {
-					foundCategories[getType(tags)] = true
-				}
-			}
-		}
-	}
-	for category := range foundCategories {
-		unique, expected, actual := map[int]bool{}, 0, 0
-		emplace := func(tags []schemametadata.IMetadataTypeTag) {
-			if sequence := protobufFactory_getSequence(tags); sequence != nil {
-				unique[*sequence] = true
-				actual++
-			}
-			expected++
-		}
-		for _, atomic := range metadata.Atomics {
-			if atomic.Type == typ {
-				for _, tags := range atomic.Tags {
-					if getType(tags) == category {
-						emplace(tags)
-					}
-				}
-			}
-		}
-		for _, constant := range metadata.Constants {
-			if constant.Type == typ {
-				for _, value := range constant.Values {
-					for _, tags := range value.Tags {
-						if getType(tags) == category {
-							emplace(tags)
-						}
-					}
-				}
-			}
-		}
-		protobufFactory_validateUniqueSequence(typ+" type", unique, expected, actual, errors, add)
-	}
+  foundCategories := map[string]bool{}
+  getType := func(tags []schemametadata.IMetadataTypeTag) string {
+    for _, tag := range tags {
+      if tag.Kind == "type" && categories[fmt.Sprint(tag.Value)] {
+        return fmt.Sprint(tag.Value)
+      }
+    }
+    return def
+  }
+  for _, atomic := range metadata.Atomics {
+    if atomic.Type == typ {
+      for _, tags := range atomic.Tags {
+        foundCategories[getType(tags)] = true
+      }
+    }
+  }
+  for _, constant := range metadata.Constants {
+    if constant.Type == typ {
+      for _, value := range constant.Values {
+        for _, tags := range value.Tags {
+          foundCategories[getType(tags)] = true
+        }
+      }
+    }
+  }
+  for category := range foundCategories {
+    unique, expected, actual := map[int]bool{}, 0, 0
+    emplace := func(tags []schemametadata.IMetadataTypeTag) {
+      if sequence := protobufFactory_getSequence(tags); sequence != nil {
+        unique[*sequence] = true
+        actual++
+      }
+      expected++
+    }
+    for _, atomic := range metadata.Atomics {
+      if atomic.Type == typ {
+        for _, tags := range atomic.Tags {
+          if getType(tags) == category {
+            emplace(tags)
+          }
+        }
+      }
+    }
+    for _, constant := range metadata.Constants {
+      if constant.Type == typ {
+        for _, value := range constant.Values {
+          for _, tags := range value.Tags {
+            if getType(tags) == category {
+              emplace(tags)
+            }
+          }
+        }
+      }
+    }
+    protobufFactory_validateUniqueSequence(typ+" type", unique, expected, actual, errors, add)
+  }
 }
 
 func protobufFactory_validateStringSequence(metadata *schemametadata.MetadataSchema, errors *[]string, add func(int) bool) {
-	unique, expected, actual := map[int]bool{}, 0, 0
-	emplace := func(matrix [][]schemametadata.IMetadataTypeTag) {
-		for _, tags := range matrix {
-			for _, tag := range tags {
-				if sequence := protobufFactory_getSequence([]schemametadata.IMetadataTypeTag{tag}); sequence != nil {
-					unique[*sequence] = true
-					actual++
-				}
-				expected++
-			}
-		}
-	}
-	for _, atomic := range metadata.Atomics {
-		if atomic.Type == "string" {
-			emplace(atomic.Tags)
-		}
-	}
-	for _, constant := range metadata.Constants {
-		if constant.Type == "string" {
-			for _, value := range constant.Values {
-				emplace(value.Tags)
-			}
-		}
-	}
-	for _, template := range metadata.Templates {
-		emplace(template.Tags)
-	}
-	protobufFactory_validateUniqueSequence("string type", unique, expected, actual, errors, add)
+  unique, expected, actual := map[int]bool{}, 0, 0
+  emplace := func(matrix [][]schemametadata.IMetadataTypeTag) {
+    for _, tags := range matrix {
+      for _, tag := range tags {
+        if sequence := protobufFactory_getSequence([]schemametadata.IMetadataTypeTag{tag}); sequence != nil {
+          unique[*sequence] = true
+          actual++
+        }
+        expected++
+      }
+    }
+  }
+  for _, atomic := range metadata.Atomics {
+    if atomic.Type == "string" {
+      emplace(atomic.Tags)
+    }
+  }
+  for _, constant := range metadata.Constants {
+    if constant.Type == "string" {
+      for _, value := range constant.Values {
+        emplace(value.Tags)
+      }
+    }
+  }
+  for _, template := range metadata.Templates {
+    emplace(template.Tags)
+  }
+  protobufFactory_validateUniqueSequence("string type", unique, expected, actual, errors, add)
 }
 
 func protobufFactory_validateInstanceSequence(typ string, tags [][]schemametadata.IMetadataTypeTag, errors *[]string, add func(int) bool) {
-	unique := map[int]bool{}
-	count := 0
-	for _, row := range tags {
-		if value := protobufFactory_getSequence(row); value != nil {
-			unique[*value] = true
-			count++
-		}
-	}
-	if len(unique) != 0 && count != len(tags) {
-		*errors = append(*errors, "The sequence tag must be declared in every union type members")
-	} else if len(unique) > 1 {
-		label := "object"
-		if typ == "array" {
-			label = "an array"
-		}
-		*errors = append(*errors, "The sequence tag value must be the same in "+label+" type.")
-	} else if len(unique) == 1 {
-		for value := range unique {
-			if add(value) == false {
-				*errors = append(*errors, fmt.Sprintf("The sequence tag value %d in %s type is duplicated with other types", value, typ))
-			}
-		}
-	}
+  unique := map[int]bool{}
+  count := 0
+  for _, row := range tags {
+    if value := protobufFactory_getSequence(row); value != nil {
+      unique[*value] = true
+      count++
+    }
+  }
+  if len(unique) != 0 && count != len(tags) {
+    *errors = append(*errors, "The sequence tag must be declared in every union type members")
+  } else if len(unique) > 1 {
+    label := "object"
+    if typ == "array" {
+      label = "an array"
+    }
+    *errors = append(*errors, "The sequence tag value must be the same in "+label+" type.")
+  } else if len(unique) == 1 {
+    for value := range unique {
+      if add(value) == false {
+        *errors = append(*errors, fmt.Sprintf("The sequence tag value %d in %s type is duplicated with other types", value, typ))
+      }
+    }
+  }
 }
 
 func protobufFactory_validateUniqueSequence(label string, unique map[int]bool, expected int, actual int, errors *[]string, add func(int) bool) {
-	if len(unique) != 0 && actual != expected {
-		*errors = append(*errors, "The sequence tag must be declared in every union type members")
-	} else if len(unique) > 1 {
-		*errors = append(*errors, "The sequence tag value must be the same in "+label+" (including literal types)")
-	} else if len(unique) == 1 {
-		for value := range unique {
-			if add(value) == false {
-				*errors = append(*errors, fmt.Sprintf("The sequence tag value %d in %s is duplicated with other types", value, label))
-			}
-		}
-	}
+  if len(unique) != 0 && actual != expected {
+    *errors = append(*errors, "The sequence tag must be declared in every union type members")
+  } else if len(unique) > 1 {
+    *errors = append(*errors, "The sequence tag value must be the same in "+label+" (including literal types)")
+  } else if len(unique) == 1 {
+    for value := range unique {
+      if add(value) == false {
+        *errors = append(*errors, fmt.Sprintf("The sequence tag value %d in %s is duplicated with other types", value, label))
+      }
+    }
+  }
 }
 
 func protobufFactory_propertyIndex(prop nativeprotobuf.IProtobufPropertyType) *int {
-	switch v := prop.(type) {
-	case *nativeprotobuf.IProtobufPropertyType_IByte:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_IBoolean:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_IBigint:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_INumber:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_IString:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_IArray:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_IObject:
-		return v.Index
-	case *nativeprotobuf.IProtobufPropertyType_IMap:
-		return v.Index
-	}
-	return nil
+  switch v := prop.(type) {
+  case *nativeprotobuf.IProtobufPropertyType_IByte:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_IBoolean:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_IBigint:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_INumber:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_IString:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_IArray:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_IObject:
+    return v.Index
+  case *nativeprotobuf.IProtobufPropertyType_IMap:
+    return v.Index
+  }
+  return nil
 }
 
 func protobufFactory_setPropertyIndex(prop nativeprotobuf.IProtobufPropertyType, index int) {
-	switch v := prop.(type) {
-	case *nativeprotobuf.IProtobufPropertyType_IByte:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_IBoolean:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_IBigint:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_INumber:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_IString:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_IArray:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_IObject:
-		v.Index = &index
-	case *nativeprotobuf.IProtobufPropertyType_IMap:
-		v.Index = &index
-	}
+  switch v := prop.(type) {
+  case *nativeprotobuf.IProtobufPropertyType_IByte:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_IBoolean:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_IBigint:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_INumber:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_IString:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_IArray:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_IObject:
+    v.Index = &index
+  case *nativeprotobuf.IProtobufPropertyType_IMap:
+    v.Index = &index
+  }
 }
 
 func protobufFactory_firstTagRow(tags [][]schemametadata.IMetadataTypeTag) []schemametadata.IMetadataTypeTag {
-	if len(tags) == 0 {
-		return []schemametadata.IMetadataTypeTag{}
-	}
-	return tags[0]
+  if len(tags) == 0 {
+    return []schemametadata.IMetadataTypeTag{}
+  }
+  return tags[0]
 }
 
 func protobufFactory_getSequence(tags []schemametadata.IMetadataTypeTag) *int {
-	for _, tag := range tags {
-		if tag.Kind != "sequence" {
-			continue
-		}
-		schema, ok := tag.Schema.(map[string]any)
-		if ok == false {
-			continue
-		}
-		raw, ok := schema["x-protobuf-sequence"]
-		if ok == false {
-			continue
-		}
-		switch value := raw.(type) {
-		case int:
-			return &value
-		case int64:
-			next := int(value)
-			return &next
-		case float64:
-			next := int(value)
-			return &next
-		case string:
-			next := 0
-			if _, err := fmt.Sscan(value, &next); err == nil {
-				return &next
-			}
-		}
-	}
-	return nil
+  for _, tag := range tags {
+    if tag.Kind != "sequence" {
+      continue
+    }
+    schema, ok := tag.Schema.(map[string]any)
+    if ok == false {
+      continue
+    }
+    raw, ok := schema["x-protobuf-sequence"]
+    if ok == false {
+      continue
+    }
+    switch value := raw.(type) {
+    case int:
+      return &value
+    case int64:
+      next := int(value)
+      return &next
+    case float64:
+      next := int(value)
+      return &next
+    case string:
+      next := 0
+      if _, err := fmt.Sscan(value, &next); err == nil {
+        return &next
+      }
+    }
+  }
+  return nil
 }
 
 func protobufFactory_isStaticObject(obj *schemametadata.MetadataObjectType) bool {
-	if obj == nil || len(obj.Properties) == 0 {
-		return false
-	}
-	for _, property := range obj.Properties {
-		if property.Key.IsSoleLiteral() == false {
-			return false
-		}
-	}
-	return true
+  if obj == nil || len(obj.Properties) == 0 {
+    return false
+  }
+  for _, property := range obj.Properties {
+    if property.Key.IsSoleLiteral() == false {
+      return false
+    }
+  }
+  return true
 }
 
 func protobufFactory_isUnion(meta *schemametadata.MetadataSchema) bool {
-	return protobufFactory_size(meta) > 1
+  return protobufFactory_size(meta) > 1
 }
 
 func protobufFactory_size(meta *schemametadata.MetadataSchema) int {
-	if meta == nil {
-		return 0
-	}
-	return len(protobufFactory_getAtomics(meta)) +
-		len(meta.Arrays) +
-		len(meta.Tuples) +
-		len(meta.Natives) +
-		len(meta.Objects) +
-		len(meta.Maps)
+  if meta == nil {
+    return 0
+  }
+  return len(protobufFactory_getAtomics(meta)) +
+    len(meta.Arrays) +
+    len(meta.Tuples) +
+    len(meta.Natives) +
+    len(meta.Objects) +
+    len(meta.Maps)
 }
 
 func protobufFactory_getAtomics(meta *schemametadata.MetadataSchema) map[string]*int {
-	output := map[string]*int{}
-	for _, constant := range meta.Constants {
-		if constant.Type == "boolean" {
-			output["bool"] = protobufFactory_getSequence(protobufFactory_firstTags(constant.Values))
-		} else if constant.Type == "bigint" {
-			init := protobufFactory_getBigintType(protobufFactory_constantValues(constant.Values))
-			protobufFactory_decodeBigint(output, constant.Values, init)
-		} else if constant.Type == "number" {
-			init := protobufFactory_getNumberType(protobufFactory_constantValues(constant.Values))
-			protobufFactory_decodeNumber(output, constant.Values, init)
-		} else if constant.Type == "string" {
-			output["string"] = protobufFactory_getSequence(protobufFactory_firstTags(constant.Values))
-		}
-	}
-	if len(meta.Templates) != 0 {
-		output["string"] = protobufFactory_getSequence(protobufFactory_firstTagRow(meta.Templates[0].Tags))
-	}
-	for _, atomic := range meta.Atomics {
-		if atomic.Type == "boolean" {
-			output["bool"] = protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags))
-		} else if atomic.Type == "bigint" {
-			protobufFactory_decodeBigintTags(output, atomic.Tags, "int64")
-		} else if atomic.Type == "number" {
-			protobufFactory_decodeNumberTags(output, atomic.Tags, "double")
-		} else if atomic.Type == "string" {
-			output["string"] = protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags))
-		}
-	}
-	return output
+  output := map[string]*int{}
+  for _, constant := range meta.Constants {
+    if constant.Type == "boolean" {
+      output["bool"] = protobufFactory_getSequence(protobufFactory_firstTags(constant.Values))
+    } else if constant.Type == "bigint" {
+      init := protobufFactory_getBigintType(protobufFactory_constantValues(constant.Values))
+      protobufFactory_decodeBigint(output, constant.Values, init)
+    } else if constant.Type == "number" {
+      init := protobufFactory_getNumberType(protobufFactory_constantValues(constant.Values))
+      protobufFactory_decodeNumber(output, constant.Values, init)
+    } else if constant.Type == "string" {
+      output["string"] = protobufFactory_getSequence(protobufFactory_firstTags(constant.Values))
+    }
+  }
+  if len(meta.Templates) != 0 {
+    output["string"] = protobufFactory_getSequence(protobufFactory_firstTagRow(meta.Templates[0].Tags))
+  }
+  for _, atomic := range meta.Atomics {
+    if atomic.Type == "boolean" {
+      output["bool"] = protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags))
+    } else if atomic.Type == "bigint" {
+      protobufFactory_decodeBigintTags(output, atomic.Tags, "int64")
+    } else if atomic.Type == "number" {
+      protobufFactory_decodeNumberTags(output, atomic.Tags, "double")
+    } else if atomic.Type == "string" {
+      output["string"] = protobufFactory_getSequence(protobufFactory_firstTagRow(atomic.Tags))
+    }
+  }
+  return output
 }
 
 func protobufFactory_getNumbers(meta *schemametadata.MetadataSchema) map[string]*int {
-	output := map[string]*int{}
-	for _, constant := range meta.Constants {
-		if constant.Type == "number" {
-			init := protobufFactory_getNumberType(protobufFactory_constantValues(constant.Values))
-			protobufFactory_decodeNumber(output, constant.Values, init)
-		}
-	}
-	for _, atomic := range meta.Atomics {
-		if atomic.Type == "number" {
-			protobufFactory_decodeNumberTags(output, atomic.Tags, "double")
-		}
-	}
-	return output
+  output := map[string]*int{}
+  for _, constant := range meta.Constants {
+    if constant.Type == "number" {
+      init := protobufFactory_getNumberType(protobufFactory_constantValues(constant.Values))
+      protobufFactory_decodeNumber(output, constant.Values, init)
+    }
+  }
+  for _, atomic := range meta.Atomics {
+    if atomic.Type == "number" {
+      protobufFactory_decodeNumberTags(output, atomic.Tags, "double")
+    }
+  }
+  return output
 }
 
 func protobufFactory_getBigints(meta *schemametadata.MetadataSchema) map[string]*int {
-	output := map[string]*int{}
-	for _, constant := range meta.Constants {
-		if constant.Type == "bigint" {
-			init := protobufFactory_getBigintType(protobufFactory_constantValues(constant.Values))
-			protobufFactory_decodeBigint(output, constant.Values, init)
-		}
-	}
-	for _, atomic := range meta.Atomics {
-		if atomic.Type == "bigint" {
-			protobufFactory_decodeBigintTags(output, atomic.Tags, "int64")
-		}
-	}
-	return output
+  output := map[string]*int{}
+  for _, constant := range meta.Constants {
+    if constant.Type == "bigint" {
+      init := protobufFactory_getBigintType(protobufFactory_constantValues(constant.Values))
+      protobufFactory_decodeBigint(output, constant.Values, init)
+    }
+  }
+  for _, atomic := range meta.Atomics {
+    if atomic.Type == "bigint" {
+      protobufFactory_decodeBigintTags(output, atomic.Tags, "int64")
+    }
+  }
+  return output
 }
 
 func protobufFactory_decodeBigint(output map[string]*int, values []*schemametadata.MetadataConstantValue, init string) {
-	for _, value := range values {
-		protobufFactory_decodeBigintTags(output, value.Tags, init)
-	}
+  for _, value := range values {
+    protobufFactory_decodeBigintTags(output, value.Tags, init)
+  }
 }
 
 func protobufFactory_decodeNumber(output map[string]*int, values []*schemametadata.MetadataConstantValue, init string) {
-	for _, value := range values {
-		protobufFactory_decodeNumberTags(output, value.Tags, init)
-	}
+  for _, value := range values {
+    protobufFactory_decodeNumberTags(output, value.Tags, init)
+  }
 }
 
 func protobufFactory_decodeBigintTags(output map[string]*int, tags [][]schemametadata.IMetadataTypeTag, init string) {
-	if len(tags) == 0 {
-		output[init] = nil
-		return
-	}
-	for _, row := range tags {
-		value := init
-		for _, tag := range row {
-			if tag.Kind == "type" && (tag.Value == "int64" || tag.Value == "uint64") {
-				value = fmt.Sprint(tag.Value)
-				break
-			}
-		}
-		output[value] = protobufFactory_getSequence(row)
-	}
+  if len(tags) == 0 {
+    output[init] = nil
+    return
+  }
+  for _, row := range tags {
+    value := init
+    for _, tag := range row {
+      if tag.Kind == "type" && (tag.Value == "int64" || tag.Value == "uint64") {
+        value = fmt.Sprint(tag.Value)
+        break
+      }
+    }
+    output[value] = protobufFactory_getSequence(row)
+  }
 }
 
 func protobufFactory_decodeNumberTags(output map[string]*int, tags [][]schemametadata.IMetadataTypeTag, init string) {
-	if len(tags) == 0 {
-		output[init] = nil
-		return
-	}
-	for _, row := range tags {
-		value := init
-		for _, tag := range row {
-			if tag.Kind != "type" {
-				continue
-			}
-			str := fmt.Sprint(tag.Value)
-			if protobufFactory_NUMBER_TYPES[str] {
-				value = str
-				break
-			}
-		}
-		output[value] = protobufFactory_getSequence(row)
-	}
+  if len(tags) == 0 {
+    output[init] = nil
+    return
+  }
+  for _, row := range tags {
+    value := init
+    for _, tag := range row {
+      if tag.Kind != "type" {
+        continue
+      }
+      str := fmt.Sprint(tag.Value)
+      if protobufFactory_NUMBER_TYPES[str] {
+        value = str
+        break
+      }
+    }
+    output[value] = protobufFactory_getSequence(row)
+  }
 }
 
 func protobufFactory_compare(x string, y string) int {
-	return protobufFactory_ATOMIC_ORDER[x] - protobufFactory_ATOMIC_ORDER[y]
+  return protobufFactory_ATOMIC_ORDER[x] - protobufFactory_ATOMIC_ORDER[y]
 }
 
 func protobufFactory_firstTags(values []*schemametadata.MetadataConstantValue) []schemametadata.IMetadataTypeTag {
-	if len(values) == 0 {
-		return []schemametadata.IMetadataTypeTag{}
-	}
-	return protobufFactory_firstTagRow(values[0].Tags)
+  if len(values) == 0 {
+    return []schemametadata.IMetadataTypeTag{}
+  }
+  return protobufFactory_firstTagRow(values[0].Tags)
 }
 
 func protobufFactory_constantValues(values []*schemametadata.MetadataConstantValue) []any {
-	output := make([]any, 0, len(values))
-	for _, value := range values {
-		output = append(output, value.Value)
-	}
-	return output
+  output := make([]any, 0, len(values))
+  for _, value := range values {
+    output = append(output, value.Value)
+  }
+  return output
 }
 
 func protobufFactory_getBigintType(values []any) string {
-	for _, value := range values {
-		if strings.HasPrefix(fmt.Sprint(value), "-") {
-			return "int64"
-		}
-	}
-	return "uint64"
+  for _, value := range values {
+    if strings.HasPrefix(fmt.Sprint(value), "-") {
+      return "int64"
+    }
+  }
+  return "uint64"
 }
 
 func protobufFactory_getNumberType(values []any) string {
-	integers := true
-	int32s := true
-	for _, value := range values {
-		number := protobufFactory_toFloat(value)
-		if math.Floor(number) != number {
-			integers = false
-			break
-		}
-		if -2147483648 <= number && number <= 2147483647 {
-			continue
-		}
-		int32s = false
-	}
-	if integers == false {
-		return "double"
-	}
-	if int32s {
-		return "int32"
-	}
-	return "int64"
+  integers := true
+  int32s := true
+  for _, value := range values {
+    number := protobufFactory_toFloat(value)
+    if math.Floor(number) != number {
+      integers = false
+      break
+    }
+    if -2147483648 <= number && number <= 2147483647 {
+      continue
+    }
+    int32s = false
+  }
+  if integers == false {
+    return "double"
+  }
+  if int32s {
+    return "int32"
+  }
+  return "int64"
 }
 
 func protobufFactory_toFloat(value any) float64 {
-	switch v := value.(type) {
-	case float64:
-		return v
-	case float32:
-		return float64(v)
-	case int:
-		return float64(v)
-	case int64:
-		return float64(v)
-	case uint64:
-		return float64(v)
-	default:
-		var out float64
-		fmt.Sscan(fmt.Sprint(value), &out)
-		return out
-	}
+  switch v := value.(type) {
+  case float64:
+    return v
+  case float32:
+    return float64(v)
+  case int:
+    return float64(v)
+  case int64:
+    return float64(v)
+  case uint64:
+    return float64(v)
+  default:
+    var out float64
+    fmt.Sscan(fmt.Sprint(value), &out)
+    return out
+  }
 }
 
 func protobufFactory_isDynamicObject(obj *schemametadata.MetadataObjectType) bool {
-	return obj != nil && len(obj.Properties) != 0 && obj.Properties[0].Key.IsSoleLiteral() == false
+  return obj != nil && len(obj.Properties) != 0 && obj.Properties[0].Key.IsSoleLiteral() == false
 }
 
 func protobufFactory_errors(errors []MetadataFactory_IError) []nativecontext.TransformerError_MetadataFactory_IError {
-	output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
-	for _, err := range errors {
-		output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
-			Name: err.Name,
-			Explore: nativecontext.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
+  output := make([]nativecontext.TransformerError_MetadataFactory_IError, 0, len(errors))
+  for _, err := range errors {
+    output = append(output, nativecontext.TransformerError_MetadataFactory_IError{
+      Name: err.Name,
+      Explore: nativecontext.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
 }
 
 var protobufFactory_BANNED_NATIVE_TYPES = map[string]string{
-	"Date":              "string",
-	"Boolean":           "boolean",
-	"BigInt":            "bigint",
-	"Number":            "number",
-	"String":            "string",
-	"Buffer":            "Uint8Array",
-	"Uint8ClampedArray": "Uint8Array",
-	"Uint16Array":       "Uint8Array",
-	"Uint32Array":       "Uint8Array",
-	"BigUint64Array":    "Uint8Array",
-	"Int8Array":         "Uint8Array",
-	"Int16Array":        "Uint8Array",
-	"Int32Array":        "Uint8Array",
-	"BigInt64Array":     "Uint8Array",
-	"Float32Array":      "Uint8Array",
-	"Float64Array":      "Uint8Array",
-	"DataView":          "Uint8Array",
-	"ArrayBuffer":       "Uint8Array",
-	"SharedArrayBuffer": "Uint8Array",
-	"WeakSet":           "Array",
-	"WeakMap":           "Map",
+  "Date":              "string",
+  "Boolean":           "boolean",
+  "BigInt":            "bigint",
+  "Number":            "number",
+  "String":            "string",
+  "Buffer":            "Uint8Array",
+  "Uint8ClampedArray": "Uint8Array",
+  "Uint16Array":       "Uint8Array",
+  "Uint32Array":       "Uint8Array",
+  "BigUint64Array":    "Uint8Array",
+  "Int8Array":         "Uint8Array",
+  "Int16Array":        "Uint8Array",
+  "Int32Array":        "Uint8Array",
+  "BigInt64Array":     "Uint8Array",
+  "Float32Array":      "Uint8Array",
+  "Float64Array":      "Uint8Array",
+  "DataView":          "Uint8Array",
+  "ArrayBuffer":       "Uint8Array",
+  "SharedArrayBuffer": "Uint8Array",
+  "WeakSet":           "Array",
+  "WeakMap":           "Map",
 }
 
 var protobufFactory_NUMBER_TYPES = map[string]bool{
-	"int32": true, "uint32": true, "int64": true, "uint64": true, "float": true, "double": true,
+  "int32": true, "uint32": true, "int64": true, "uint64": true, "float": true, "double": true,
 }
 var protobufFactory_BIGINT_TYPES = map[string]bool{"int64": true, "uint64": true}
 var protobufFactory_ATOMIC_ORDER = map[string]int{
-	"bool":   0,
-	"int32":  1,
-	"uint32": 2,
-	"int64":  3,
-	"uint64": 4,
-	"float":  5,
-	"double": 6,
-	"string": 7,
+  "bool":   0,
+  "int32":  1,
+  "uint32": 2,
+  "int64":  3,
+  "uint64": 4,
+  "float":  5,
+  "double": 6,
+  "string": 7,
 }