typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/http/HttpHeadersProgrammer.go

@@ -1,428 +1,428 @@
-package http
-
-import (
-  "fmt"
-  "sort"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
-  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type httpHeadersProgrammerNamespace struct{}
-
-var HttpHeadersProgrammer = httpHeadersProgrammerNamespace{}
-
-const HttpHeadersProgrammer_INPUT_TYPE = "Record<string, string | string[] | undefined>"
-
-type HttpHeadersProgrammer_DecomposeProps struct {
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-  Type    *shimchecker.Type
-  Name    *string
-}
-
-var httpHeadersProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func (httpHeadersProgrammerNamespace) Decompose(props HttpHeadersProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
-  collection := schemametadata.NewMetadataCollection()
-  result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
-    Checker: props.Context.Checker,
-    Options: nativefactories.MetadataFactory_IOptions{
-      Escape:   false,
-      Constant: true,
-      Absorb:   true,
-      Validate: HttpHeadersProgrammer.Validate,
-    },
-    Components: collection,
-    Type:       props.Type,
-  })
-  if result.Success == false {
-    panic(nativecontext.TransformerError_from(struct {
-      Code   string
-      Errors []nativecontext.TransformerError_MetadataFactory_IError
-    }{
-      Code:   props.Functor.Method,
-      Errors: httpParameterProgrammer_errors(result.Errors),
-    }))
-  }
-
-  object := result.Data.Objects[0].Type
-  statements := httpHeadersProgrammer_decode_object(struct {
-    Context nativecontext.ITypiaContext
-    Object  *schemametadata.MetadataObjectType
-  }{
-    Context: props.Context,
-    Object:  object,
-  })
-  return nativeinternal.FeatureProgrammer_IDecomposed{
-    Functions:  map[string]*shimast.Node{},
-    Statements: []*shimast.Node{},
-    Arrow: f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList([]*shimast.Node{
-        nativefactories.IdentifierFactory.Parameter(
-          "input",
-          f.NewTypeReferenceNode(f.NewIdentifier(HttpHeadersProgrammer_INPUT_TYPE), nil),
-          nil,
-          props.Context.Emit,
-        ),
-      }),
-      httpProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
-        File: "typia",
-        Name: "Resolved",
-        Arguments: []*shimast.TypeNode{
-          httpProgrammer_typeReference(props.Context, props.Type, props.Name),
-        },
-      }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      f.NewBlock(f.NewNodeList(statements), true),
-    ),
-  }
-}
-
-func (httpHeadersProgrammerNamespace) Write(props nativecontext.IProgrammerProps) *shimast.Node {
-  functor := nativehelpers.NewFunctionProgrammer(httpProgrammer_method_text(props.Modulo), props.Context.Emit)
-  result := HttpHeadersProgrammer.Decompose(HttpHeadersProgrammer_DecomposeProps{
-    Context: props.Context,
-    Functor: functor,
-    Type:    props.Type,
-    Name:    props.Name,
-  })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-    Modulo:  props.Modulo,
-    Functor: functor,
-    Result:  result,
-  })
-}
-
-func (httpHeadersProgrammerNamespace) Validate(props struct {
-  Metadata *schemametadata.MetadataSchema
-  Explore  nativefactories.MetadataFactory_IExplore
-  Top      *schemametadata.MetadataSchema
-}) []string {
-  errors := []string{}
-  insert := func(msg string) {
-    errors = append(errors, msg)
-  }
-
-  if props.Explore.Top == true {
-    if len(props.Metadata.Objects) != 1 || props.Metadata.Bucket() != 1 {
-      insert("only one object type is allowed.")
-    }
-    if props.Metadata.Nullable == true {
-      insert("headers cannot be null.")
-    }
-    if props.Metadata.IsRequired() == false {
-      insert("headers cannot be null.")
-    }
-  } else if _, ok := props.Explore.Nested.(*schemametadata.MetadataArrayType); props.Explore.Nested != nil && ok {
-    atomics := nativehelpers.HttpMetadataUtil.Atomics(props.Metadata)
-    expected := len(props.Metadata.Atomics) + len(props.Metadata.Templates)
-    for _, c := range props.Metadata.Constants {
-      expected += len(c.Values)
-    }
-    if len(atomics) > 1 {
-      insert("union type is not allowed in array.")
-    }
-    if props.Metadata.Size() != expected {
-      insert("only atomic or constant types are allowed in array.")
-    }
-    if props.Metadata.Nullable == true {
-      insert("nullable type is not allowed in array.")
-    }
-    if props.Metadata.IsRequired() == false {
-      insert("optional type is not allowed in array.")
-    }
-  } else if props.Explore.Object != nil && props.Explore.Property != nil {
-    if _, ok := props.Explore.Property.(string); ok == false {
-      insert("dynamic property is not allowed.")
-    }
-    if len(props.Metadata.Tuples) != 0 {
-      insert("tuple type is not allowed.")
-    }
-    if nativehelpers.HttpMetadataUtil.IsUnion(props.Metadata) {
-      insert("union type is not allowed.")
-    }
-    if len(props.Metadata.Objects) != 0 ||
-      len(props.Metadata.Sets) != 0 ||
-      len(props.Metadata.Maps) != 0 ||
-      len(props.Metadata.Natives) != 0 {
-      insert("nested object type is not allowed.")
-    }
-    if props.Metadata.Nullable == true {
-      insert("nullable type is not allowed.")
-    }
-
-    isArray := len(props.Metadata.Arrays) >= 1 || len(props.Metadata.Tuples) >= 1
-    if key, ok := props.Explore.Property.(string); ok {
-      lower := strings.ToLower(key)
-      if lower == "set-cookie" && isArray == false {
-        insert(fmt.Sprintf("%s property must be array.", key))
-      }
-      if httpHeadersProgrammer_SINGULAR[lower] && isArray == true {
-        insert("property cannot be array.")
-      }
-    }
-  } else if props.Explore.Object != nil && props.Explore.Property == nil {
-    counter := map[string]map[string]bool{}
-    for _, prop := range props.Explore.Object.Properties {
-      key := prop.Key.GetSoleLiteral()
-      if key == nil {
-        continue
-      }
-      lower := strings.ToLower(*key)
-      if counter[lower] == nil {
-        counter[lower] = map[string]bool{}
-      }
-      counter[lower][*key] = true
-    }
-    keys := make([]string, 0, len(counter))
-    for key := range counter {
-      keys = append(keys, key)
-    }
-    sort.Strings(keys)
-    for _, key := range keys {
-      set := counter[key]
-      if len(set) <= 1 {
-        continue
-      }
-      values := make([]string, 0, len(set))
-      for value := range set {
-        values = append(values, value)
-      }
-      sort.Strings(values)
-      insert(fmt.Sprintf("duplicated keys when converting to lowercase letters: [%s] -> %s", strings.Join(values, ", "), key))
-    }
-  }
-  return errors
-}
-
-func httpHeadersProgrammer_decode_object(props struct {
-  Context nativecontext.ITypiaContext
-  Object  *schemametadata.MetadataObjectType
-}) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
-  output := f.NewIdentifier("output")
-  optionals := []string{}
-  properties := make([]*shimast.Node, 0, len(props.Object.Properties))
-  for _, p := range props.Object.Properties {
-    if p.Value.IsRequired() == false && len(p.Value.Arrays)+len(p.Value.Tuples) > 0 {
-      optionals = append(optionals, httpProgrammer_property_key(p))
-    }
-    properties = append(properties, httpHeadersProgrammer_decode_regular_property(struct {
-      Context  nativecontext.ITypiaContext
-      Property *schemametadata.MetadataProperty
-    }{
-      Context:  props.Context,
-      Property: p,
-    }))
-  }
-  statements := []*shimast.Node{
-    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: "output",
-      Value: f.NewObjectLiteralExpression(
-        f.NewNodeList(properties),
-        true,
-      ),
-    }, props.Context.Emit),
-  }
-  for _, key := range optionals {
-    access := nativefactories.IdentifierFactory.Access(props.Context.Emit, output, key)
-    statements = append(statements, f.NewIfStatement(
-      f.NewBinaryExpression(
-        nil,
-        nativefactories.ExpressionFactory.Number(0, props.Context.Emit),
-        nil,
-        f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-        nativefactories.IdentifierFactory.Access(props.Context.Emit, access, "length"),
-      ),
-      f.NewExpressionStatement(
-        f.NewDeleteExpression(access),
-      ),
-      nil,
-    ))
-  }
-  statements = append(statements, f.NewReturnStatement(
-    f.NewAsExpression(output, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
-  ))
-  return statements
-}
-
-func httpHeadersProgrammer_decode_regular_property(props struct {
-  Context  nativecontext.ITypiaContext
-  Property *schemametadata.MetadataProperty
-}) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
-  key := httpProgrammer_property_key(props.Property)
-  value := props.Property.Value
-  typ, isArray := httpProgrammer_decode_type(value, false)
-  input := nativefactories.IdentifierFactory.Access(
-    props.Context.Emit,
-    f.NewIdentifier("input"),
-    strings.ToLower(key),
-  )
-  var decoded *shimast.Node
-  if isArray {
-    if key == "set-cookie" {
-      decoded = input
-    } else {
-      decoded = httpHeadersProgrammer_decode_array(struct {
-        Context nativecontext.ITypiaContext
-        Type    string
-        Key     string
-        Value   *schemametadata.MetadataSchema
-        Input   *shimast.Node
-      }{
-        Context: props.Context,
-        Type:    typ,
-        Key:     key,
-        Value:   value,
-        Input:   input,
-      })
-    }
-  } else {
-    decoded = httpHeadersProgrammer_decode_value(struct {
-      Context nativecontext.ITypiaContext
-      Type    string
-      Input   *shimast.Node
-    }{
-      Context: props.Context,
-      Type:    typ,
-      Input:   input,
-    })
-  }
-  return f.NewPropertyAssignment(
-    nil,
-    nativefactories.IdentifierFactory.Identifier(key, props.Context.Emit),
-    nil,
-    nil,
-    decoded,
-  )
-}
-
-func httpHeadersProgrammer_decode_value(props struct {
-  Context nativecontext.ITypiaContext
-  Type    string
-  Input   *shimast.Node
-}) *shimast.Node {
-  if props.Type == "string" {
-    return props.Input
-  }
-  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
-  return f.NewCallExpression(
-    httpParameterProgrammer_internal(props.Context, "httpHeaderRead"+httpParameterProgrammer_capitalize(props.Type)),
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{props.Input}),
-    shimast.NodeFlagsNone,
-  )
-}
-
-func httpHeadersProgrammer_decode_array(props struct {
-  Context nativecontext.ITypiaContext
-  Type    string
-  Key     string
-  Value   *schemametadata.MetadataSchema
-  Input   *shimast.Node
-}) *shimast.Node {
-  // The reader helper is registered as an import side effect, so it must only be
-  // requested for non-string types; string[] headers map inline (str => str.trim())
-  // and must not pull in a non-existent _httpHeaderReadString helper. Mirrors the
-  // scalar path (decode_value), which short-circuits string before building a reader.
-  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
-  var reader *shimast.Node
-  if props.Type == "string" {
-    reader = f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList([]*shimast.Node{
-        nativefactories.IdentifierFactory.Parameter("str", nil, nil, props.Context.Emit),
-      }),
-      nil,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      f.NewCallExpression(
-        nativefactories.IdentifierFactory.Access(props.Context.Emit, f.NewIdentifier("str"), "trim"),
-        nil,
-        nil,
-        nil,
-        shimast.NodeFlagsNone,
-      ),
-    )
-  } else {
-    reader = httpParameterProgrammer_internal(props.Context, "httpHeaderRead"+httpParameterProgrammer_capitalize(props.Type))
-  }
-  delimiter := ", "
-  if props.Key == "cookie" {
-    delimiter = "; "
-  }
-  split := f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Input, "split", true),
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{
-      f.NewStringLiteral(delimiter, shimast.TokenFlagsNone),
-    }),
-    shimast.NodeFlagsOptionalChain,
-  )
-  mappedSplit := f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(props.Context.Emit, split, "map", true),
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{reader}),
-    shimast.NodeFlagsOptionalChain,
-  )
-  arrayMap := f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Input, "map"),
-    nil,
-    nil,
-    f.NewNodeList([]*shimast.Node{reader}),
-    shimast.NodeFlagsNone,
-  )
-  otherwise := mappedSplit
-  if props.Value.IsRequired() {
-    otherwise = f.NewBinaryExpression(
-      nil,
-      mappedSplit,
-      nil,
-      f.NewToken(shimast.KindQuestionQuestionToken),
-      f.NewArrayLiteralExpression(f.NewNodeList(nil), false),
-    )
-  }
-  return nativefactories.ExpressionFactory.Conditional(
-    nativefactories.ExpressionFactory.IsArray(props.Input, props.Context.Emit),
-    arrayMap,
-    otherwise,
-    props.Context.Emit,
-  )
-}
-
-var httpHeadersProgrammer_SINGULAR = map[string]bool{
-  "age":                 true,
-  "authorization":       true,
-  "content-length":      true,
-  "content-type":        true,
-  "etag":                true,
-  "expires":             true,
-  "from":                true,
-  "host":                true,
-  "if-modified-since":   true,
-  "if-unmodified-since": true,
-  "last-modified":       true,
-  "location":            true,
-  "max-forwards":        true,
-  "proxy-authorization": true,
-  "referer":             true,
-  "retry-after":         true,
-  "server":              true,
-  "user-agent":          true,
-}
+package http
+
+import (
+  "fmt"
+  "sort"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type httpHeadersProgrammerNamespace struct{}
+
+var HttpHeadersProgrammer = httpHeadersProgrammerNamespace{}
+
+const HttpHeadersProgrammer_INPUT_TYPE = "Record<string, string | string[] | undefined>"
+
+type HttpHeadersProgrammer_DecomposeProps struct {
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Type    *shimchecker.Type
+  Name    *string
+}
+
+var httpHeadersProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (httpHeadersProgrammerNamespace) Decompose(props HttpHeadersProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
+  collection := schemametadata.NewMetadataCollection()
+  result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{
+    Checker: props.Context.Checker,
+    Options: nativefactories.MetadataFactory_IOptions{
+      Escape:   false,
+      Constant: true,
+      Absorb:   true,
+      Validate: HttpHeadersProgrammer.Validate,
+    },
+    Components: collection,
+    Type:       props.Type,
+  })
+  if result.Success == false {
+    panic(nativecontext.TransformerError_from(struct {
+      Code   string
+      Errors []nativecontext.TransformerError_MetadataFactory_IError
+    }{
+      Code:   props.Functor.Method,
+      Errors: httpParameterProgrammer_errors(result.Errors),
+    }))
+  }
+
+  object := result.Data.Objects[0].Type
+  statements := httpHeadersProgrammer_decode_object(struct {
+    Context nativecontext.ITypiaContext
+    Object  *schemametadata.MetadataObjectType
+  }{
+    Context: props.Context,
+    Object:  object,
+  })
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  map[string]*shimast.Node{},
+    Statements: []*shimast.Node{},
+    Arrow: f.NewArrowFunction(
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{
+        nativefactories.IdentifierFactory.Parameter(
+          "input",
+          f.NewTypeReferenceNode(f.NewIdentifier(HttpHeadersProgrammer_INPUT_TYPE), nil),
+          nil,
+          props.Context.Emit,
+        ),
+      }),
+      httpProgrammer_import_type(props.Context, nativecontext.ImportProgrammer_TypeProps{
+        File: "typia",
+        Name: "Resolved",
+        Arguments: []*shimast.TypeNode{
+          httpProgrammer_typeReference(props.Context, props.Type, props.Name),
+        },
+      }),
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      f.NewBlock(f.NewNodeList(statements), true),
+    ),
+  }
+}
+
+func (httpHeadersProgrammerNamespace) Write(props nativecontext.IProgrammerProps) *shimast.Node {
+  functor := nativehelpers.NewFunctionProgrammer(httpProgrammer_method_text(props.Modulo), props.Context.Emit)
+  result := HttpHeadersProgrammer.Decompose(HttpHeadersProgrammer_DecomposeProps{
+    Context: props.Context,
+    Functor: functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
+}
+
+func (httpHeadersProgrammerNamespace) Validate(props struct {
+  Metadata *schemametadata.MetadataSchema
+  Explore  nativefactories.MetadataFactory_IExplore
+  Top      *schemametadata.MetadataSchema
+}) []string {
+  errors := []string{}
+  insert := func(msg string) {
+    errors = append(errors, msg)
+  }
+
+  if props.Explore.Top == true {
+    if len(props.Metadata.Objects) != 1 || props.Metadata.Bucket() != 1 {
+      insert("only one object type is allowed.")
+    }
+    if props.Metadata.Nullable == true {
+      insert("headers cannot be null.")
+    }
+    if props.Metadata.IsRequired() == false {
+      insert("headers cannot be null.")
+    }
+  } else if _, ok := props.Explore.Nested.(*schemametadata.MetadataArrayType); props.Explore.Nested != nil && ok {
+    atomics := nativehelpers.HttpMetadataUtil.Atomics(props.Metadata)
+    expected := len(props.Metadata.Atomics) + len(props.Metadata.Templates)
+    for _, c := range props.Metadata.Constants {
+      expected += len(c.Values)
+    }
+    if len(atomics) > 1 {
+      insert("union type is not allowed in array.")
+    }
+    if props.Metadata.Size() != expected {
+      insert("only atomic or constant types are allowed in array.")
+    }
+    if props.Metadata.Nullable == true {
+      insert("nullable type is not allowed in array.")
+    }
+    if props.Metadata.IsRequired() == false {
+      insert("optional type is not allowed in array.")
+    }
+  } else if props.Explore.Object != nil && props.Explore.Property != nil {
+    if _, ok := props.Explore.Property.(string); ok == false {
+      insert("dynamic property is not allowed.")
+    }
+    if len(props.Metadata.Tuples) != 0 {
+      insert("tuple type is not allowed.")
+    }
+    if nativehelpers.HttpMetadataUtil.IsUnion(props.Metadata) {
+      insert("union type is not allowed.")
+    }
+    if len(props.Metadata.Objects) != 0 ||
+      len(props.Metadata.Sets) != 0 ||
+      len(props.Metadata.Maps) != 0 ||
+      len(props.Metadata.Natives) != 0 {
+      insert("nested object type is not allowed.")
+    }
+    if props.Metadata.Nullable == true {
+      insert("nullable type is not allowed.")
+    }
+
+    isArray := len(props.Metadata.Arrays) >= 1 || len(props.Metadata.Tuples) >= 1
+    if key, ok := props.Explore.Property.(string); ok {
+      lower := strings.ToLower(key)
+      if lower == "set-cookie" && isArray == false {
+        insert(fmt.Sprintf("%s property must be array.", key))
+      }
+      if httpHeadersProgrammer_SINGULAR[lower] && isArray == true {
+        insert("property cannot be array.")
+      }
+    }
+  } else if props.Explore.Object != nil && props.Explore.Property == nil {
+    counter := map[string]map[string]bool{}
+    for _, prop := range props.Explore.Object.Properties {
+      key := prop.Key.GetSoleLiteral()
+      if key == nil {
+        continue
+      }
+      lower := strings.ToLower(*key)
+      if counter[lower] == nil {
+        counter[lower] = map[string]bool{}
+      }
+      counter[lower][*key] = true
+    }
+    keys := make([]string, 0, len(counter))
+    for key := range counter {
+      keys = append(keys, key)
+    }
+    sort.Strings(keys)
+    for _, key := range keys {
+      set := counter[key]
+      if len(set) <= 1 {
+        continue
+      }
+      values := make([]string, 0, len(set))
+      for value := range set {
+        values = append(values, value)
+      }
+      sort.Strings(values)
+      insert(fmt.Sprintf("duplicated keys when converting to lowercase letters: [%s] -> %s", strings.Join(values, ", "), key))
+    }
+  }
+  return errors
+}
+
+func httpHeadersProgrammer_decode_object(props struct {
+  Context nativecontext.ITypiaContext
+  Object  *schemametadata.MetadataObjectType
+}) []*shimast.Node {
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
+  output := f.NewIdentifier("output")
+  optionals := []string{}
+  properties := make([]*shimast.Node, 0, len(props.Object.Properties))
+  for _, p := range props.Object.Properties {
+    if p.Value.IsRequired() == false && len(p.Value.Arrays)+len(p.Value.Tuples) > 0 {
+      optionals = append(optionals, httpProgrammer_property_key(p))
+    }
+    properties = append(properties, httpHeadersProgrammer_decode_regular_property(struct {
+      Context  nativecontext.ITypiaContext
+      Property *schemametadata.MetadataProperty
+    }{
+      Context:  props.Context,
+      Property: p,
+    }))
+  }
+  statements := []*shimast.Node{
+    nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name: "output",
+      Value: f.NewObjectLiteralExpression(
+        f.NewNodeList(properties),
+        true,
+      ),
+    }, props.Context.Emit),
+  }
+  for _, key := range optionals {
+    access := nativefactories.IdentifierFactory.Access(props.Context.Emit, output, key)
+    statements = append(statements, f.NewIfStatement(
+      f.NewBinaryExpression(
+        nil,
+        nativefactories.ExpressionFactory.Number(0, props.Context.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+        nativefactories.IdentifierFactory.Access(props.Context.Emit, access, "length"),
+      ),
+      f.NewExpressionStatement(
+        f.NewDeleteExpression(access),
+      ),
+      nil,
+    ))
+  }
+  statements = append(statements, f.NewReturnStatement(
+    f.NewAsExpression(output, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
+  ))
+  return statements
+}
+
+func httpHeadersProgrammer_decode_regular_property(props struct {
+  Context  nativecontext.ITypiaContext
+  Property *schemametadata.MetadataProperty
+}) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
+  key := httpProgrammer_property_key(props.Property)
+  value := props.Property.Value
+  typ, isArray := httpProgrammer_decode_type(value, false)
+  input := nativefactories.IdentifierFactory.Access(
+    props.Context.Emit,
+    f.NewIdentifier("input"),
+    strings.ToLower(key),
+  )
+  var decoded *shimast.Node
+  if isArray {
+    if key == "set-cookie" {
+      decoded = input
+    } else {
+      decoded = httpHeadersProgrammer_decode_array(struct {
+        Context nativecontext.ITypiaContext
+        Type    string
+        Key     string
+        Value   *schemametadata.MetadataSchema
+        Input   *shimast.Node
+      }{
+        Context: props.Context,
+        Type:    typ,
+        Key:     key,
+        Value:   value,
+        Input:   input,
+      })
+    }
+  } else {
+    decoded = httpHeadersProgrammer_decode_value(struct {
+      Context nativecontext.ITypiaContext
+      Type    string
+      Input   *shimast.Node
+    }{
+      Context: props.Context,
+      Type:    typ,
+      Input:   input,
+    })
+  }
+  return f.NewPropertyAssignment(
+    nil,
+    nativefactories.IdentifierFactory.Identifier(key, props.Context.Emit),
+    nil,
+    nil,
+    decoded,
+  )
+}
+
+func httpHeadersProgrammer_decode_value(props struct {
+  Context nativecontext.ITypiaContext
+  Type    string
+  Input   *shimast.Node
+}) *shimast.Node {
+  if props.Type == "string" {
+    return props.Input
+  }
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
+  return f.NewCallExpression(
+    httpParameterProgrammer_internal(props.Context, "httpHeaderRead"+httpParameterProgrammer_capitalize(props.Type)),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{props.Input}),
+    shimast.NodeFlagsNone,
+  )
+}
+
+func httpHeadersProgrammer_decode_array(props struct {
+  Context nativecontext.ITypiaContext
+  Type    string
+  Key     string
+  Value   *schemametadata.MetadataSchema
+  Input   *shimast.Node
+}) *shimast.Node {
+  // The reader helper is registered as an import side effect, so it must only be
+  // requested for non-string types; string[] headers map inline (str => str.trim())
+  // and must not pull in a non-existent _httpHeaderReadString helper. Mirrors the
+  // scalar path (decode_value), which short-circuits string before building a reader.
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, props.Context.Emit)
+  var reader *shimast.Node
+  if props.Type == "string" {
+    reader = f.NewArrowFunction(
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{
+        nativefactories.IdentifierFactory.Parameter("str", nil, nil, props.Context.Emit),
+      }),
+      nil,
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      f.NewCallExpression(
+        nativefactories.IdentifierFactory.Access(props.Context.Emit, f.NewIdentifier("str"), "trim"),
+        nil,
+        nil,
+        nil,
+        shimast.NodeFlagsNone,
+      ),
+    )
+  } else {
+    reader = httpParameterProgrammer_internal(props.Context, "httpHeaderRead"+httpParameterProgrammer_capitalize(props.Type))
+  }
+  delimiter := ", "
+  if props.Key == "cookie" {
+    delimiter = "; "
+  }
+  split := f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Input, "split", true),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewStringLiteral(delimiter, shimast.TokenFlagsNone),
+    }),
+    shimast.NodeFlagsOptionalChain,
+  )
+  mappedSplit := f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(props.Context.Emit, split, "map", true),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{reader}),
+    shimast.NodeFlagsOptionalChain,
+  )
+  arrayMap := f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Input, "map"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{reader}),
+    shimast.NodeFlagsNone,
+  )
+  otherwise := mappedSplit
+  if props.Value.IsRequired() {
+    otherwise = f.NewBinaryExpression(
+      nil,
+      mappedSplit,
+      nil,
+      f.NewToken(shimast.KindQuestionQuestionToken),
+      f.NewArrayLiteralExpression(f.NewNodeList(nil), false),
+    )
+  }
+  return nativefactories.ExpressionFactory.Conditional(
+    nativefactories.ExpressionFactory.IsArray(props.Input, props.Context.Emit),
+    arrayMap,
+    otherwise,
+    props.Context.Emit,
+  )
+}
+
+var httpHeadersProgrammer_SINGULAR = map[string]bool{
+  "age":                 true,
+  "authorization":       true,
+  "content-length":      true,
+  "content-type":        true,
+  "etag":                true,
+  "expires":             true,
+  "from":                true,
+  "host":                true,
+  "if-modified-since":   true,
+  "if-unmodified-since": true,
+  "last-modified":       true,
+  "location":            true,
+  "max-forwards":        true,
+  "proxy-authorization": true,
+  "referer":             true,
+  "retry-after":         true,
+  "server":              true,
+  "user-agent":          true,
+}