diff --git a/changelog/@unreleased/pr-579.v2.yml b/changelog/@unreleased/pr-579.v2.yml
new file mode 100644
index 00000000..35b59b0c
--- /dev/null
+++ b/changelog/@unreleased/pr-579.v2.yml
@@ -0,0 +1,5 @@
+type: feature
+feature:
+  description: Define Encoding methods for endpoint bodies via private aliases
+  links:
+  - https://github.com/palantir/conjure-go/pull/579
diff --git a/conjure-api/conjure/spec/aliases.conjure.go b/conjure-api/conjure/spec/aliases.conjure.go
index f615021d..d8af7dd7 100644
--- a/conjure-api/conjure/spec/aliases.conjure.go
+++ b/conjure-api/conjure/spec/aliases.conjure.go
@@ -4,14 +4,17 @@ package spec
 
 // Must be in lowerCamelCase. Numbers are permitted, but not at the beginning of a word. Allowed argument names: "fooBar", "build2Request". Disallowed names: "FooBar", "2BuildRequest".
 type ArgumentName string
+
 type Documentation string
 
 // Should be in lowerCamelCase.
 type EndpointName string
+
 type ErrorNamespace string
 
 // Should be in lowerCamelCase, but kebab-case and snake_case are also permitted.
 type FieldName string
+
 type HttpPath string
 
 // For header parameters, the parameter id must be in Upper-Kebab-Case. For query parameters, the parameter id must be in lowerCamelCase. Numbers are permitted, but not at the beginning of a word.
diff --git a/conjure-go-verifier/conjure/verification/types/aliases.conjure.go b/conjure-go-verifier/conjure/verification/types/aliases.conjure.go
index f05ec279..50eb643e 100644
--- a/conjure-go-verifier/conjure/verification/types/aliases.conjure.go
+++ b/conjure-go-verifier/conjure/verification/types/aliases.conjure.go
@@ -15,6 +15,7 @@ import (
 )
 
 type AliasString string
+
 type BearerTokenAliasExample bearertoken.Token
 
 func (a BearerTokenAliasExample) String() string {
@@ -86,6 +87,7 @@ func (a *BinaryAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) er
 }
 
 type BooleanAliasExample bool
+
 type DateTimeAliasExample datetime.DateTime
 
 func (a DateTimeAliasExample) String() string {
@@ -122,12 +124,52 @@ func (a *DateTimeAliasExample) UnmarshalYAML(unmarshal func(interface{}) error)
 }
 
 type DoubleAliasExample float64
+
 type IntegerAliasExample int
+
 type ListAnyAliasExample []interface{}
+
+func (a ListAnyAliasExample) MarshalJSON() ([]byte, error) {
+	rawListAnyAliasExample := []interface{}(a)
+	if rawListAnyAliasExample == nil {
+		rawListAnyAliasExample = make([]interface{}, 0)
+	}
+	return safejson.Marshal(rawListAnyAliasExample)
+}
+
+func (a *ListAnyAliasExample) UnmarshalJSON(data []byte) error {
+	var rawListAnyAliasExample []interface{}
+	if err := safejson.Unmarshal(data, &rawListAnyAliasExample); err != nil {
+		return err
+	}
+	*a = ListAnyAliasExample(rawListAnyAliasExample)
+	return nil
+}
+
+func (a ListAnyAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListAnyAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type ListBearerTokenAliasExample []bearertoken.Token
 
 func (a ListBearerTokenAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]bearertoken.Token(a))
+	rawListBearerTokenAliasExample := []bearertoken.Token(a)
+	if rawListBearerTokenAliasExample == nil {
+		rawListBearerTokenAliasExample = make([]bearertoken.Token, 0)
+	}
+	return safejson.Marshal(rawListBearerTokenAliasExample)
 }
 
 func (a *ListBearerTokenAliasExample) UnmarshalJSON(data []byte) error {
@@ -158,7 +200,11 @@ func (a *ListBearerTokenAliasExample) UnmarshalYAML(unmarshal func(interface{})
 type ListBinaryAliasExample [][]byte
 
 func (a ListBinaryAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([][]byte(a))
+	rawListBinaryAliasExample := [][]byte(a)
+	if rawListBinaryAliasExample == nil {
+		rawListBinaryAliasExample = make([][]byte, 0)
+	}
+	return safejson.Marshal(rawListBinaryAliasExample)
 }
 
 func (a *ListBinaryAliasExample) UnmarshalJSON(data []byte) error {
@@ -187,10 +233,48 @@ func (a *ListBinaryAliasExample) UnmarshalYAML(unmarshal func(interface{}) error
 }
 
 type ListBooleanAliasExample []bool
+
+func (a ListBooleanAliasExample) MarshalJSON() ([]byte, error) {
+	rawListBooleanAliasExample := []bool(a)
+	if rawListBooleanAliasExample == nil {
+		rawListBooleanAliasExample = make([]bool, 0)
+	}
+	return safejson.Marshal(rawListBooleanAliasExample)
+}
+
+func (a *ListBooleanAliasExample) UnmarshalJSON(data []byte) error {
+	var rawListBooleanAliasExample []bool
+	if err := safejson.Unmarshal(data, &rawListBooleanAliasExample); err != nil {
+		return err
+	}
+	*a = ListBooleanAliasExample(rawListBooleanAliasExample)
+	return nil
+}
+
+func (a ListBooleanAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListBooleanAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type ListDateTimeAliasExample []datetime.DateTime
 
 func (a ListDateTimeAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]datetime.DateTime(a))
+	rawListDateTimeAliasExample := []datetime.DateTime(a)
+	if rawListDateTimeAliasExample == nil {
+		rawListDateTimeAliasExample = make([]datetime.DateTime, 0)
+	}
+	return safejson.Marshal(rawListDateTimeAliasExample)
 }
 
 func (a *ListDateTimeAliasExample) UnmarshalJSON(data []byte) error {
@@ -219,12 +303,118 @@ func (a *ListDateTimeAliasExample) UnmarshalYAML(unmarshal func(interface{}) err
 }
 
 type ListDoubleAliasExample []float64
+
+func (a ListDoubleAliasExample) MarshalJSON() ([]byte, error) {
+	rawListDoubleAliasExample := []float64(a)
+	if rawListDoubleAliasExample == nil {
+		rawListDoubleAliasExample = make([]float64, 0)
+	}
+	return safejson.Marshal(rawListDoubleAliasExample)
+}
+
+func (a *ListDoubleAliasExample) UnmarshalJSON(data []byte) error {
+	var rawListDoubleAliasExample []float64
+	if err := safejson.Unmarshal(data, &rawListDoubleAliasExample); err != nil {
+		return err
+	}
+	*a = ListDoubleAliasExample(rawListDoubleAliasExample)
+	return nil
+}
+
+func (a ListDoubleAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListDoubleAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type ListIntegerAliasExample []int
+
+func (a ListIntegerAliasExample) MarshalJSON() ([]byte, error) {
+	rawListIntegerAliasExample := []int(a)
+	if rawListIntegerAliasExample == nil {
+		rawListIntegerAliasExample = make([]int, 0)
+	}
+	return safejson.Marshal(rawListIntegerAliasExample)
+}
+
+func (a *ListIntegerAliasExample) UnmarshalJSON(data []byte) error {
+	var rawListIntegerAliasExample []int
+	if err := safejson.Unmarshal(data, &rawListIntegerAliasExample); err != nil {
+		return err
+	}
+	*a = ListIntegerAliasExample(rawListIntegerAliasExample)
+	return nil
+}
+
+func (a ListIntegerAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListIntegerAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type ListOptionalAnyAliasExample []*interface{}
+
+func (a ListOptionalAnyAliasExample) MarshalJSON() ([]byte, error) {
+	rawListOptionalAnyAliasExample := []*interface{}(a)
+	if rawListOptionalAnyAliasExample == nil {
+		rawListOptionalAnyAliasExample = make([]*interface{}, 0)
+	}
+	return safejson.Marshal(rawListOptionalAnyAliasExample)
+}
+
+func (a *ListOptionalAnyAliasExample) UnmarshalJSON(data []byte) error {
+	var rawListOptionalAnyAliasExample []*interface{}
+	if err := safejson.Unmarshal(data, &rawListOptionalAnyAliasExample); err != nil {
+		return err
+	}
+	*a = ListOptionalAnyAliasExample(rawListOptionalAnyAliasExample)
+	return nil
+}
+
+func (a ListOptionalAnyAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListOptionalAnyAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type ListRidAliasExample []rid.ResourceIdentifier
 
 func (a ListRidAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]rid.ResourceIdentifier(a))
+	rawListRidAliasExample := []rid.ResourceIdentifier(a)
+	if rawListRidAliasExample == nil {
+		rawListRidAliasExample = make([]rid.ResourceIdentifier, 0)
+	}
+	return safejson.Marshal(rawListRidAliasExample)
 }
 
 func (a *ListRidAliasExample) UnmarshalJSON(data []byte) error {
@@ -255,7 +445,11 @@ func (a *ListRidAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) e
 type ListSafeLongAliasExample []safelong.SafeLong
 
 func (a ListSafeLongAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]safelong.SafeLong(a))
+	rawListSafeLongAliasExample := []safelong.SafeLong(a)
+	if rawListSafeLongAliasExample == nil {
+		rawListSafeLongAliasExample = make([]safelong.SafeLong, 0)
+	}
+	return safejson.Marshal(rawListSafeLongAliasExample)
 }
 
 func (a *ListSafeLongAliasExample) UnmarshalJSON(data []byte) error {
@@ -284,10 +478,48 @@ func (a *ListSafeLongAliasExample) UnmarshalYAML(unmarshal func(interface{}) err
 }
 
 type ListStringAliasExample []string
+
+func (a ListStringAliasExample) MarshalJSON() ([]byte, error) {
+	rawListStringAliasExample := []string(a)
+	if rawListStringAliasExample == nil {
+		rawListStringAliasExample = make([]string, 0)
+	}
+	return safejson.Marshal(rawListStringAliasExample)
+}
+
+func (a *ListStringAliasExample) UnmarshalJSON(data []byte) error {
+	var rawListStringAliasExample []string
+	if err := safejson.Unmarshal(data, &rawListStringAliasExample); err != nil {
+		return err
+	}
+	*a = ListStringAliasExample(rawListStringAliasExample)
+	return nil
+}
+
+func (a ListStringAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListStringAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type ListUuidAliasExample []uuid.UUID
 
 func (a ListUuidAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]uuid.UUID(a))
+	rawListUuidAliasExample := []uuid.UUID(a)
+	if rawListUuidAliasExample == nil {
+		rawListUuidAliasExample = make([]uuid.UUID, 0)
+	}
+	return safejson.Marshal(rawListUuidAliasExample)
 }
 
 func (a *ListUuidAliasExample) UnmarshalJSON(data []byte) error {
@@ -318,7 +550,11 @@ func (a *ListUuidAliasExample) UnmarshalYAML(unmarshal func(interface{}) error)
 type MapBearerTokenAliasExample map[bearertoken.Token]bool
 
 func (a MapBearerTokenAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[bearertoken.Token]bool(a))
+	rawMapBearerTokenAliasExample := map[bearertoken.Token]bool(a)
+	if rawMapBearerTokenAliasExample == nil {
+		rawMapBearerTokenAliasExample = make(map[bearertoken.Token]bool, 0)
+	}
+	return safejson.Marshal(rawMapBearerTokenAliasExample)
 }
 
 func (a *MapBearerTokenAliasExample) UnmarshalJSON(data []byte) error {
@@ -349,7 +585,11 @@ func (a *MapBearerTokenAliasExample) UnmarshalYAML(unmarshal func(interface{}) e
 type MapBinaryAliasExample map[binary.Binary]bool
 
 func (a MapBinaryAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[binary.Binary]bool(a))
+	rawMapBinaryAliasExample := map[binary.Binary]bool(a)
+	if rawMapBinaryAliasExample == nil {
+		rawMapBinaryAliasExample = make(map[binary.Binary]bool, 0)
+	}
+	return safejson.Marshal(rawMapBinaryAliasExample)
 }
 
 func (a *MapBinaryAliasExample) UnmarshalJSON(data []byte) error {
@@ -378,10 +618,48 @@ func (a *MapBinaryAliasExample) UnmarshalYAML(unmarshal func(interface{}) error)
 }
 
 type MapBooleanAliasExample map[boolean.Boolean]bool
+
+func (a MapBooleanAliasExample) MarshalJSON() ([]byte, error) {
+	rawMapBooleanAliasExample := map[boolean.Boolean]bool(a)
+	if rawMapBooleanAliasExample == nil {
+		rawMapBooleanAliasExample = make(map[boolean.Boolean]bool, 0)
+	}
+	return safejson.Marshal(rawMapBooleanAliasExample)
+}
+
+func (a *MapBooleanAliasExample) UnmarshalJSON(data []byte) error {
+	var rawMapBooleanAliasExample map[boolean.Boolean]bool
+	if err := safejson.Unmarshal(data, &rawMapBooleanAliasExample); err != nil {
+		return err
+	}
+	*a = MapBooleanAliasExample(rawMapBooleanAliasExample)
+	return nil
+}
+
+func (a MapBooleanAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapBooleanAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapDateTimeAliasExample map[datetime.DateTime]bool
 
 func (a MapDateTimeAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[datetime.DateTime]bool(a))
+	rawMapDateTimeAliasExample := map[datetime.DateTime]bool(a)
+	if rawMapDateTimeAliasExample == nil {
+		rawMapDateTimeAliasExample = make(map[datetime.DateTime]bool, 0)
+	}
+	return safejson.Marshal(rawMapDateTimeAliasExample)
 }
 
 func (a *MapDateTimeAliasExample) UnmarshalJSON(data []byte) error {
@@ -410,10 +688,48 @@ func (a *MapDateTimeAliasExample) UnmarshalYAML(unmarshal func(interface{}) erro
 }
 
 type MapDoubleAliasExample map[float64]bool
+
+func (a MapDoubleAliasExample) MarshalJSON() ([]byte, error) {
+	rawMapDoubleAliasExample := map[float64]bool(a)
+	if rawMapDoubleAliasExample == nil {
+		rawMapDoubleAliasExample = make(map[float64]bool, 0)
+	}
+	return safejson.Marshal(rawMapDoubleAliasExample)
+}
+
+func (a *MapDoubleAliasExample) UnmarshalJSON(data []byte) error {
+	var rawMapDoubleAliasExample map[float64]bool
+	if err := safejson.Unmarshal(data, &rawMapDoubleAliasExample); err != nil {
+		return err
+	}
+	*a = MapDoubleAliasExample(rawMapDoubleAliasExample)
+	return nil
+}
+
+func (a MapDoubleAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapDoubleAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapEnumExampleAlias map[EnumExample]string
 
 func (a MapEnumExampleAlias) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[EnumExample]string(a))
+	rawMapEnumExampleAlias := map[EnumExample]string(a)
+	if rawMapEnumExampleAlias == nil {
+		rawMapEnumExampleAlias = make(map[EnumExample]string, 0)
+	}
+	return safejson.Marshal(rawMapEnumExampleAlias)
 }
 
 func (a *MapEnumExampleAlias) UnmarshalJSON(data []byte) error {
@@ -442,10 +758,48 @@ func (a *MapEnumExampleAlias) UnmarshalYAML(unmarshal func(interface{}) error) e
 }
 
 type MapIntegerAliasExample map[int]bool
+
+func (a MapIntegerAliasExample) MarshalJSON() ([]byte, error) {
+	rawMapIntegerAliasExample := map[int]bool(a)
+	if rawMapIntegerAliasExample == nil {
+		rawMapIntegerAliasExample = make(map[int]bool, 0)
+	}
+	return safejson.Marshal(rawMapIntegerAliasExample)
+}
+
+func (a *MapIntegerAliasExample) UnmarshalJSON(data []byte) error {
+	var rawMapIntegerAliasExample map[int]bool
+	if err := safejson.Unmarshal(data, &rawMapIntegerAliasExample); err != nil {
+		return err
+	}
+	*a = MapIntegerAliasExample(rawMapIntegerAliasExample)
+	return nil
+}
+
+func (a MapIntegerAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapIntegerAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapRidAliasExample map[rid.ResourceIdentifier]bool
 
 func (a MapRidAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[rid.ResourceIdentifier]bool(a))
+	rawMapRidAliasExample := map[rid.ResourceIdentifier]bool(a)
+	if rawMapRidAliasExample == nil {
+		rawMapRidAliasExample = make(map[rid.ResourceIdentifier]bool, 0)
+	}
+	return safejson.Marshal(rawMapRidAliasExample)
 }
 
 func (a *MapRidAliasExample) UnmarshalJSON(data []byte) error {
@@ -476,7 +830,11 @@ func (a *MapRidAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) er
 type MapSafeLongAliasExample map[safelong.SafeLong]bool
 
 func (a MapSafeLongAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[safelong.SafeLong]bool(a))
+	rawMapSafeLongAliasExample := map[safelong.SafeLong]bool(a)
+	if rawMapSafeLongAliasExample == nil {
+		rawMapSafeLongAliasExample = make(map[safelong.SafeLong]bool, 0)
+	}
+	return safejson.Marshal(rawMapSafeLongAliasExample)
 }
 
 func (a *MapSafeLongAliasExample) UnmarshalJSON(data []byte) error {
@@ -505,10 +863,48 @@ func (a *MapSafeLongAliasExample) UnmarshalYAML(unmarshal func(interface{}) erro
 }
 
 type MapStringAliasExample map[string]bool
+
+func (a MapStringAliasExample) MarshalJSON() ([]byte, error) {
+	rawMapStringAliasExample := map[string]bool(a)
+	if rawMapStringAliasExample == nil {
+		rawMapStringAliasExample = make(map[string]bool, 0)
+	}
+	return safejson.Marshal(rawMapStringAliasExample)
+}
+
+func (a *MapStringAliasExample) UnmarshalJSON(data []byte) error {
+	var rawMapStringAliasExample map[string]bool
+	if err := safejson.Unmarshal(data, &rawMapStringAliasExample); err != nil {
+		return err
+	}
+	*a = MapStringAliasExample(rawMapStringAliasExample)
+	return nil
+}
+
+func (a MapStringAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapStringAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapUuidAliasExample map[uuid.UUID]bool
 
 func (a MapUuidAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[uuid.UUID]bool(a))
+	rawMapUuidAliasExample := map[uuid.UUID]bool(a)
+	if rawMapUuidAliasExample == nil {
+		rawMapUuidAliasExample = make(map[uuid.UUID]bool, 0)
+	}
+	return safejson.Marshal(rawMapUuidAliasExample)
 }
 
 func (a *MapUuidAliasExample) UnmarshalJSON(data []byte) error {
@@ -1042,10 +1438,48 @@ func (a *SafeLongAliasExample) UnmarshalYAML(unmarshal func(interface{}) error)
 }
 
 type SetAnyAliasExample []interface{}
+
+func (a SetAnyAliasExample) MarshalJSON() ([]byte, error) {
+	rawSetAnyAliasExample := []interface{}(a)
+	if rawSetAnyAliasExample == nil {
+		rawSetAnyAliasExample = make([]interface{}, 0)
+	}
+	return safejson.Marshal(rawSetAnyAliasExample)
+}
+
+func (a *SetAnyAliasExample) UnmarshalJSON(data []byte) error {
+	var rawSetAnyAliasExample []interface{}
+	if err := safejson.Unmarshal(data, &rawSetAnyAliasExample); err != nil {
+		return err
+	}
+	*a = SetAnyAliasExample(rawSetAnyAliasExample)
+	return nil
+}
+
+func (a SetAnyAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *SetAnyAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type SetBearerTokenAliasExample []bearertoken.Token
 
 func (a SetBearerTokenAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]bearertoken.Token(a))
+	rawSetBearerTokenAliasExample := []bearertoken.Token(a)
+	if rawSetBearerTokenAliasExample == nil {
+		rawSetBearerTokenAliasExample = make([]bearertoken.Token, 0)
+	}
+	return safejson.Marshal(rawSetBearerTokenAliasExample)
 }
 
 func (a *SetBearerTokenAliasExample) UnmarshalJSON(data []byte) error {
@@ -1076,7 +1510,11 @@ func (a *SetBearerTokenAliasExample) UnmarshalYAML(unmarshal func(interface{}) e
 type SetBinaryAliasExample [][]byte
 
 func (a SetBinaryAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([][]byte(a))
+	rawSetBinaryAliasExample := [][]byte(a)
+	if rawSetBinaryAliasExample == nil {
+		rawSetBinaryAliasExample = make([][]byte, 0)
+	}
+	return safejson.Marshal(rawSetBinaryAliasExample)
 }
 
 func (a *SetBinaryAliasExample) UnmarshalJSON(data []byte) error {
@@ -1105,10 +1543,48 @@ func (a *SetBinaryAliasExample) UnmarshalYAML(unmarshal func(interface{}) error)
 }
 
 type SetBooleanAliasExample []bool
+
+func (a SetBooleanAliasExample) MarshalJSON() ([]byte, error) {
+	rawSetBooleanAliasExample := []bool(a)
+	if rawSetBooleanAliasExample == nil {
+		rawSetBooleanAliasExample = make([]bool, 0)
+	}
+	return safejson.Marshal(rawSetBooleanAliasExample)
+}
+
+func (a *SetBooleanAliasExample) UnmarshalJSON(data []byte) error {
+	var rawSetBooleanAliasExample []bool
+	if err := safejson.Unmarshal(data, &rawSetBooleanAliasExample); err != nil {
+		return err
+	}
+	*a = SetBooleanAliasExample(rawSetBooleanAliasExample)
+	return nil
+}
+
+func (a SetBooleanAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *SetBooleanAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type SetDateTimeAliasExample []datetime.DateTime
 
 func (a SetDateTimeAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]datetime.DateTime(a))
+	rawSetDateTimeAliasExample := []datetime.DateTime(a)
+	if rawSetDateTimeAliasExample == nil {
+		rawSetDateTimeAliasExample = make([]datetime.DateTime, 0)
+	}
+	return safejson.Marshal(rawSetDateTimeAliasExample)
 }
 
 func (a *SetDateTimeAliasExample) UnmarshalJSON(data []byte) error {
@@ -1137,12 +1613,118 @@ func (a *SetDateTimeAliasExample) UnmarshalYAML(unmarshal func(interface{}) erro
 }
 
 type SetDoubleAliasExample []float64
+
+func (a SetDoubleAliasExample) MarshalJSON() ([]byte, error) {
+	rawSetDoubleAliasExample := []float64(a)
+	if rawSetDoubleAliasExample == nil {
+		rawSetDoubleAliasExample = make([]float64, 0)
+	}
+	return safejson.Marshal(rawSetDoubleAliasExample)
+}
+
+func (a *SetDoubleAliasExample) UnmarshalJSON(data []byte) error {
+	var rawSetDoubleAliasExample []float64
+	if err := safejson.Unmarshal(data, &rawSetDoubleAliasExample); err != nil {
+		return err
+	}
+	*a = SetDoubleAliasExample(rawSetDoubleAliasExample)
+	return nil
+}
+
+func (a SetDoubleAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *SetDoubleAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type SetIntegerAliasExample []int
+
+func (a SetIntegerAliasExample) MarshalJSON() ([]byte, error) {
+	rawSetIntegerAliasExample := []int(a)
+	if rawSetIntegerAliasExample == nil {
+		rawSetIntegerAliasExample = make([]int, 0)
+	}
+	return safejson.Marshal(rawSetIntegerAliasExample)
+}
+
+func (a *SetIntegerAliasExample) UnmarshalJSON(data []byte) error {
+	var rawSetIntegerAliasExample []int
+	if err := safejson.Unmarshal(data, &rawSetIntegerAliasExample); err != nil {
+		return err
+	}
+	*a = SetIntegerAliasExample(rawSetIntegerAliasExample)
+	return nil
+}
+
+func (a SetIntegerAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *SetIntegerAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type SetOptionalAnyAliasExample []*interface{}
+
+func (a SetOptionalAnyAliasExample) MarshalJSON() ([]byte, error) {
+	rawSetOptionalAnyAliasExample := []*interface{}(a)
+	if rawSetOptionalAnyAliasExample == nil {
+		rawSetOptionalAnyAliasExample = make([]*interface{}, 0)
+	}
+	return safejson.Marshal(rawSetOptionalAnyAliasExample)
+}
+
+func (a *SetOptionalAnyAliasExample) UnmarshalJSON(data []byte) error {
+	var rawSetOptionalAnyAliasExample []*interface{}
+	if err := safejson.Unmarshal(data, &rawSetOptionalAnyAliasExample); err != nil {
+		return err
+	}
+	*a = SetOptionalAnyAliasExample(rawSetOptionalAnyAliasExample)
+	return nil
+}
+
+func (a SetOptionalAnyAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *SetOptionalAnyAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type SetRidAliasExample []rid.ResourceIdentifier
 
 func (a SetRidAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]rid.ResourceIdentifier(a))
+	rawSetRidAliasExample := []rid.ResourceIdentifier(a)
+	if rawSetRidAliasExample == nil {
+		rawSetRidAliasExample = make([]rid.ResourceIdentifier, 0)
+	}
+	return safejson.Marshal(rawSetRidAliasExample)
 }
 
 func (a *SetRidAliasExample) UnmarshalJSON(data []byte) error {
@@ -1173,7 +1755,11 @@ func (a *SetRidAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) er
 type SetSafeLongAliasExample []safelong.SafeLong
 
 func (a SetSafeLongAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]safelong.SafeLong(a))
+	rawSetSafeLongAliasExample := []safelong.SafeLong(a)
+	if rawSetSafeLongAliasExample == nil {
+		rawSetSafeLongAliasExample = make([]safelong.SafeLong, 0)
+	}
+	return safejson.Marshal(rawSetSafeLongAliasExample)
 }
 
 func (a *SetSafeLongAliasExample) UnmarshalJSON(data []byte) error {
@@ -1202,10 +1788,48 @@ func (a *SetSafeLongAliasExample) UnmarshalYAML(unmarshal func(interface{}) erro
 }
 
 type SetStringAliasExample []string
+
+func (a SetStringAliasExample) MarshalJSON() ([]byte, error) {
+	rawSetStringAliasExample := []string(a)
+	if rawSetStringAliasExample == nil {
+		rawSetStringAliasExample = make([]string, 0)
+	}
+	return safejson.Marshal(rawSetStringAliasExample)
+}
+
+func (a *SetStringAliasExample) UnmarshalJSON(data []byte) error {
+	var rawSetStringAliasExample []string
+	if err := safejson.Unmarshal(data, &rawSetStringAliasExample); err != nil {
+		return err
+	}
+	*a = SetStringAliasExample(rawSetStringAliasExample)
+	return nil
+}
+
+func (a SetStringAliasExample) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *SetStringAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type SetUuidAliasExample []uuid.UUID
 
 func (a SetUuidAliasExample) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]uuid.UUID(a))
+	rawSetUuidAliasExample := []uuid.UUID(a)
+	if rawSetUuidAliasExample == nil {
+		rawSetUuidAliasExample = make([]uuid.UUID, 0)
+	}
+	return safejson.Marshal(rawSetUuidAliasExample)
 }
 
 func (a *SetUuidAliasExample) UnmarshalJSON(data []byte) error {
@@ -1234,6 +1858,7 @@ func (a *SetUuidAliasExample) UnmarshalYAML(unmarshal func(interface{}) error) e
 }
 
 type StringAliasExample string
+
 type UuidAliasExample uuid.UUID
 
 func (a UuidAliasExample) String() string {
diff --git a/conjure/aliaswriter.go b/conjure/aliaswriter.go
index af9eafe4..38f45e51 100644
--- a/conjure/aliaswriter.go
+++ b/conjure/aliaswriter.go
@@ -90,6 +90,10 @@ func writeNonOptionalAliasType(file *jen.Group, aliasDef *types.AliasType) {
 			file.Add(astForAliasString(typeName, aliasDef.Item.Code()))
 			file.Add(astForAliasTextMarshal(typeName, aliasDef.Item.Code()))
 			file.Add(astForAliasTextUnmarshal(typeName, aliasDef.Item.Code()))
+		} else if aliasDef.IsCollection() {
+			// Collection types need to send [] and {} when empty.
+			file.Add(astForAliasCollectionJSONMarshal(typeName, aliasDef.Item.Code(), aliasDef.Make()))
+			file.Add(astForAliasJSONUnmarshal(typeName, aliasDef.Item.Code()))
 		} else {
 			// By default, we delegate json/yaml encoding to the aliased type.
 			file.Add(astForAliasJSONMarshal(typeName, aliasDef.Item.Code()))
@@ -106,10 +110,6 @@ func isSimpleAliasType(t types.Type) bool {
 	case types.Any, types.Boolean, types.Double, types.Integer, types.String:
 		// Plain builtins do not need encoding methods; do nothing.
 		return true
-	case *types.List:
-		return isSimpleAliasType(v.Item)
-	case *types.Map:
-		return isSimpleAliasType(v.Key) && isSimpleAliasType(v.Val)
 	case *types.Optional:
 		return isSimpleAliasType(v.Item)
 	case *types.AliasType:
@@ -228,6 +228,16 @@ func astForAliasOptionalJSONMarshal(typeName string) *jen.Statement {
 	)
 }
 
+func astForAliasCollectionJSONMarshal(typeName string, aliasGoType *jen.Statement, aliasValueInit *jen.Statement) *jen.Statement {
+	rawVarName := "raw" + typeName
+	return snip.MethodMarshalJSON(aliasReceiverName, typeName).Block(
+		jen.Id(rawVarName).Op(":=").Add(aliasGoType.Clone().Call(jen.Id(aliasReceiverName))),
+		jen.If(jen.Id(rawVarName).Op("==").Nil()).Block(
+			jen.Id(rawVarName).Op("=").Add(aliasValueInit.Clone())),
+		jen.Return(snip.SafeJSONMarshal().Call(jen.Id(rawVarName))),
+	)
+}
+
 func astForAliasJSONUnmarshal(typeName string, aliasGoType *jen.Statement) *jen.Statement {
 	rawVarName := "raw" + typeName
 	return snip.MethodUnmarshalJSON(aliasReceiverName, typeName).Block(
diff --git a/conjure/conjure.go b/conjure/conjure.go
index cf9fc707..802a2e87 100644
--- a/conjure/conjure.go
+++ b/conjure/conjure.go
@@ -51,6 +51,11 @@ func GenerateOutputFiles(conjureDefinition spec.ConjureDefinition, cfg OutputCon
 			aliasFile := newJenFile(pkg, def)
 			for _, alias := range pkg.Aliases {
 				writeAliasType(aliasFile.Group, alias)
+				aliasFile.Line()
+			}
+			for _, alias := range collectPrivateAliasTypes(pkg.Services) {
+				aliasFile.Commentf("%s provides encoding methods suitable for conjure collections.", alias.Name)
+				writeAliasType(aliasFile.Group, alias)
 			}
 			files = append(files, newGoFile(filepath.Join(pkg.OutputDir, "aliases.conjure.go"), aliasFile))
 		}
diff --git a/conjure/serverwriter.go b/conjure/serverwriter.go
index 4041e594..84d23be6 100644
--- a/conjure/serverwriter.go
+++ b/conjure/serverwriter.go
@@ -167,7 +167,7 @@ func astForHandlerMethodBody(methodBody *jen.Group, serviceName string, endpoint
 	astForHandlerMethodPathParams(methodBody, endpointDef.PathParams())
 	astForHandlerMethodQueryParams(methodBody, endpointDef.QueryParams())
 	astForHandlerMethodHeaderParams(methodBody, endpointDef.HeaderParams())
-	astForHandlerMethodDecodeBody(methodBody, endpointDef.BodyParam())
+	astForHandlerMethodDecodeBody(methodBody, endpointDef.BodyParam(), serviceName, endpointDef.EndpointName)
 	// call impl handler & return
 	astForHandlerExecImplAndReturn(methodBody, serviceName, endpointDef)
 }
@@ -264,7 +264,7 @@ func astForHandlerMethodQueryParam(methodBody *jen.Group, argDef *types.Endpoint
 	astForDecodeHTTPParam(methodBody, argDef.Name, argDef.Type, transforms.ArgName(argDef.Name), reqCtxExpr, queryVar)
 }
 
-func astForHandlerMethodDecodeBody(methodBody *jen.Group, argDef *types.EndpointArgumentDefinition) {
+func astForHandlerMethodDecodeBody(methodBody *jen.Group, argDef *types.EndpointArgumentDefinition, serviceName, endpointName string) {
 	if argDef == nil {
 		return
 	}
@@ -287,10 +287,15 @@ func astForHandlerMethodDecodeBody(methodBody *jen.Group, argDef *types.Endpoint
 		return
 	}
 	// If the request is not binary, it is JSON. Unmarshal the req.Body.
+	jsonArg := jen.Op("&").Id(varName)
+	if needsPrivateAlias(argDef.Type) {
+		aliasName := namePrivateAliasRequestType(serviceName, endpointName)
+		jsonArg = jen.Parens(jen.Op("*").Id(aliasName)).Call(jsonArg)
+	}
 	decodeJSON := jen.If(
 		jen.Err().Op(":=").Add(snip.CGRCodecsJSON().Dot("Decode")).Call(
 			jen.Id(reqName).Dot("Body"),
-			jen.Op("&").Id(varName),
+			jsonArg,
 		),
 		jen.Err().Op("!=").Nil(),
 	).Block(jen.Return(snip.CGRErrorsWrapWithInvalidArgument().Call(jen.Err())))
@@ -479,6 +484,11 @@ func astForHandlerExecImplAndReturn(g *jen.Group, serviceName string, endpointDe
 	codec := snip.CGRCodecsJSON()
 	if (*endpointDef.Returns).IsBinary() {
 		codec = snip.CGRCodecsBinary()
+	} else {
+		if needsPrivateAlias(*endpointDef.Returns) {
+			aliasName := namePrivateAliasResponseType(serviceName, endpointDef.EndpointName)
+			respArg = jen.Id(aliasName).Call(respArg.Clone())
+		}
 	}
 	g.Id(responseWriterVarName).Dot("Header").Call().Dot("Add").Call(
 		jen.Lit("Content-Type"),
diff --git a/conjure/serverwriter_test.go b/conjure/serverwriter_test.go
index 5b268641..a319145e 100644
--- a/conjure/serverwriter_test.go
+++ b/conjure/serverwriter_test.go
@@ -529,7 +529,7 @@ func TestServerASTDecodeHTTPParam(t *testing.T) {
 				case types.QueryParam:
 					astForHandlerMethodQueryParam(g, &test.Arg)
 				case types.BodyParam:
-					astForHandlerMethodDecodeBody(g, &test.Arg)
+					astForHandlerMethodDecodeBody(g, &test.Arg, "MyService", "MyEndpoint")
 				}
 			})
 			var buf bytes.Buffer
diff --git a/conjure/servicewriter.go b/conjure/servicewriter.go
index 7eab57af..5ea14b72 100644
--- a/conjure/servicewriter.go
+++ b/conjure/servicewriter.go
@@ -227,12 +227,12 @@ func astForEndpointMethod(serviceName string, endpointDef *types.EndpointDefinit
 			if withAuth {
 				astForEndpointAuthMethodBodyFunc(methodBody, endpointDef)
 			} else {
-				astForEndpointMethodBodyFunc(methodBody, endpointDef)
+				astForEndpointMethodBodyFunc(methodBody, serviceName, endpointDef)
 			}
 		})
 }
 
-func astForEndpointMethodBodyFunc(methodBody *jen.Group, endpointDef *types.EndpointDefinition) {
+func astForEndpointMethodBodyFunc(methodBody *jen.Group, serviceName string, endpointDef *types.EndpointDefinition) {
 	var (
 		hasReturnVal         = endpointDef.Returns != nil
 		returnsBinary        = hasReturnVal && (*endpointDef.Returns).IsBinary()
@@ -266,7 +266,7 @@ func astForEndpointMethodBodyFunc(methodBody *jen.Group, endpointDef *types.Endp
 	}
 
 	// build requestParams
-	astForEndpointMethodBodyRequestParams(methodBody, endpointDef)
+	astForEndpointMethodBodyRequestParams(methodBody, serviceName, endpointDef)
 
 	// execute request
 	callStmt := jen.Id(clientReceiverName).Dot(clientStructFieldName).Dot("Do").Call(
@@ -323,8 +323,8 @@ func astForEndpointMethodBodyFunc(methodBody *jen.Group, endpointDef *types.Endp
 	}
 }
 
-func astForEndpointMethodBodyRequestParams(methodBody *jen.Group, endpointDef *types.EndpointDefinition) {
-	methodBody.Var().Id(requestParamsVar).Op("[]").Add(snip.CGRClientRequestParam())
+func astForEndpointMethodBodyRequestParams(methodBody *jen.Group, serviceName string, endpointDef *types.EndpointDefinition) {
+	methodBody.Var().Id(requestParamsVar).Index().Add(snip.CGRClientRequestParam())
 
 	// helper for the statement "requestParams = append(requestParams, {code})"
 	appendRequestParams := func(methodBody *jen.Group, code jen.Code) {
@@ -353,6 +353,18 @@ func astForEndpointMethodBodyRequestParams(methodBody *jen.Group, endpointDef *t
 	// body params
 	if body := endpointDef.BodyParam(); body != nil {
 		bodyArg := transforms.ArgName(body.Name)
+		doAppendBodyRequestParam := func(block *jen.Group) {
+			if body.Type.IsBinary() {
+				appendRequestParams(block, snip.CGRClientWithRawRequestBodyProvider().Call(jen.Id(bodyArg)))
+			} else {
+				jsonArg := jen.Id(bodyArg)
+				if needsPrivateAlias(body.Type) {
+					aliasName := namePrivateAliasRequestType(serviceName, endpointDef.EndpointName)
+					jsonArg = jen.Id(aliasName).Call(jsonArg)
+				}
+				appendRequestParams(block, snip.CGRClientWithJSONRequest().Call(jsonArg))
+			}
+		}
 		if body.Type.IsOptional() {
 			bodyVal := jen.Id(bodyArg)
 			if body.Type.IsNamed() && !body.Type.IsBinary() {
@@ -360,16 +372,10 @@ func astForEndpointMethodBodyRequestParams(methodBody *jen.Group, endpointDef *t
 				bodyVal = bodyVal.Dot("Value")
 			}
 			methodBody.If(bodyVal.Clone().Op("!=").Nil()).BlockFunc(func(ifBody *jen.Group) {
-				if body.Type.IsBinary() {
-					appendRequestParams(ifBody, snip.CGRClientWithRawRequestBodyProvider().Call(jen.Id(bodyArg)))
-				} else {
-					appendRequestParams(ifBody, snip.CGRClientWithJSONRequest().Call(jen.Id(bodyArg)))
-				}
+				doAppendBodyRequestParam(ifBody)
 			})
-		} else if body.Type.IsBinary() {
-			appendRequestParams(methodBody, snip.CGRClientWithRawRequestBodyProvider().Call(jen.Id(bodyArg)))
 		} else {
-			appendRequestParams(methodBody, snip.CGRClientWithJSONRequest().Call(jen.Id(bodyArg)))
+			doAppendBodyRequestParam(methodBody)
 		}
 	}
 	// header params
@@ -424,7 +430,12 @@ func astForEndpointMethodBodyRequestParams(methodBody *jen.Group, endpointDef *t
 		if (*endpointDef.Returns).IsBinary() {
 			appendRequestParams(methodBody, snip.CGRClientWithRawResponseBody().Call())
 		} else {
-			appendRequestParams(methodBody, snip.CGRClientWithJSONResponse().Call(jen.Op("&").Id(returnValVar)))
+			jsonArg := jen.Op("&").Id(returnValVar)
+			if needsPrivateAlias(*endpointDef.Returns) {
+				aliasName := namePrivateAliasResponseType(serviceName, endpointDef.EndpointName)
+				jsonArg = jen.Parens(jen.Op("*").Id(aliasName)).Call(jsonArg)
+			}
+			appendRequestParams(methodBody, snip.CGRClientWithJSONResponse().Call(jsonArg))
 		}
 	}
 }
@@ -525,6 +536,61 @@ func astForTokenServiceEndpointMethod(serviceName string, endpointDef *types.End
 		})
 }
 
+// BEGIN Private aliases for endpoint bodies //
+//
+// Private aliases are used to wrap endpoint request and response bodies whose types' default JSON serialization
+// does not match the encoding/json standard handling.
+
+func needsPrivateAlias(typ types.Type) bool {
+	if typ.IsNamed() || typ.IsBinary() {
+		return false
+	}
+	if opt, ok := typ.(*types.Optional); ok {
+		return needsPrivateAlias(opt.Item)
+	}
+	if typ.IsCollection() {
+		return true
+	}
+	return false
+}
+
+func namePrivateAliasRequestType(serviceName, endpointName string) string {
+	return "requestBody" + transforms.Export(serviceName) + transforms.Export(endpointName)
+}
+
+func namePrivateAliasResponseType(serviceName, endpointName string) string {
+	return "responseBody" + transforms.Export(serviceName) + transforms.Export(endpointName)
+}
+
+func collectPrivateAliasTypes(services []*types.ServiceDefinition) []*types.AliasType {
+	var aliases []*types.AliasType
+	for _, serviceDef := range services {
+		for _, endpointDef := range serviceDef.Endpoints {
+			// request body
+			if body := endpointDef.BodyParam(); body != nil {
+				if needsPrivateAlias(body.Type) {
+					aliases = append(aliases, &types.AliasType{
+						Name: namePrivateAliasRequestType(serviceDef.Name, endpointDef.EndpointName),
+						Item: body.Type,
+					})
+				}
+			}
+			// response body
+			if endpointDef.Returns != nil {
+				if needsPrivateAlias(*endpointDef.Returns) {
+					aliases = append(aliases, &types.AliasType{
+						Name: namePrivateAliasResponseType(serviceDef.Name, endpointDef.EndpointName),
+						Item: *endpointDef.Returns,
+					})
+				}
+			}
+		}
+	}
+	return aliases
+}
+
+/// END private aliases for endpoint bodies ///
+
 func interfaceTypeName(serviceName string) string {
 	return transforms.Export(serviceName)
 }
diff --git a/cycles/testdata/cycle-within-pkg/conjure/com/palantir/bar/aliases.conjure.go b/cycles/testdata/cycle-within-pkg/conjure/com/palantir/bar/aliases.conjure.go
index c7dfdf3d..5b0133f2 100644
--- a/cycles/testdata/cycle-within-pkg/conjure/com/palantir/bar/aliases.conjure.go
+++ b/cycles/testdata/cycle-within-pkg/conjure/com/palantir/bar/aliases.conjure.go
@@ -10,7 +10,11 @@ import (
 type Type1 []Type3
 
 func (a Type1) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]Type3(a))
+	rawType1 := []Type3(a)
+	if rawType1 == nil {
+		rawType1 = make([]Type3, 0)
+	}
+	return safejson.Marshal(rawType1)
 }
 
 func (a *Type1) UnmarshalJSON(data []byte) error {
diff --git a/cycles/testdata/cycle-within-pkg/conjure/com/palantir/foo/aliases.conjure.go b/cycles/testdata/cycle-within-pkg/conjure/com/palantir/foo/aliases.conjure.go
index 3605ff75..dfdf3517 100644
--- a/cycles/testdata/cycle-within-pkg/conjure/com/palantir/foo/aliases.conjure.go
+++ b/cycles/testdata/cycle-within-pkg/conjure/com/palantir/foo/aliases.conjure.go
@@ -11,7 +11,11 @@ import (
 type Type2 map[fizz.Type1]Type1
 
 func (a Type2) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[fizz.Type1]Type1(a))
+	rawType2 := map[fizz.Type1]Type1(a)
+	if rawType2 == nil {
+		rawType2 = make(map[fizz.Type1]Type1, 0)
+	}
+	return safejson.Marshal(rawType2)
 }
 
 func (a *Type2) UnmarshalJSON(data []byte) error {
diff --git a/cycles/testdata/no-cycles/conjure/com/palantir/bar/aliases.conjure.go b/cycles/testdata/no-cycles/conjure/com/palantir/bar/aliases.conjure.go
index c7dfdf3d..5b0133f2 100644
--- a/cycles/testdata/no-cycles/conjure/com/palantir/bar/aliases.conjure.go
+++ b/cycles/testdata/no-cycles/conjure/com/palantir/bar/aliases.conjure.go
@@ -10,7 +10,11 @@ import (
 type Type1 []Type3
 
 func (a Type1) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]Type3(a))
+	rawType1 := []Type3(a)
+	if rawType1 == nil {
+		rawType1 = make([]Type3, 0)
+	}
+	return safejson.Marshal(rawType1)
 }
 
 func (a *Type1) UnmarshalJSON(data []byte) error {
diff --git a/cycles/testdata/no-cycles/conjure/com/palantir/foo/aliases.conjure.go b/cycles/testdata/no-cycles/conjure/com/palantir/foo/aliases.conjure.go
index 2019d25b..b1a6c810 100644
--- a/cycles/testdata/no-cycles/conjure/com/palantir/foo/aliases.conjure.go
+++ b/cycles/testdata/no-cycles/conjure/com/palantir/foo/aliases.conjure.go
@@ -11,7 +11,11 @@ import (
 type Type2 map[fizz.Type1]Type4
 
 func (a Type2) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[fizz.Type1]Type4(a))
+	rawType2 := map[fizz.Type1]Type4(a)
+	if rawType2 == nil {
+		rawType2 = make(map[fizz.Type1]Type4, 0)
+	}
+	return safejson.Marshal(rawType2)
 }
 
 func (a *Type2) UnmarshalJSON(data []byte) error {
diff --git a/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/bar/aliases.conjure.go b/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/bar/aliases.conjure.go
index dbf83671..6e9cad26 100644
--- a/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/bar/aliases.conjure.go
+++ b/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/bar/aliases.conjure.go
@@ -8,6 +8,40 @@ import (
 )
 
 type Type1 []Type2
+
+func (a Type1) MarshalJSON() ([]byte, error) {
+	rawType1 := []Type2(a)
+	if rawType1 == nil {
+		rawType1 = make([]Type2, 0)
+	}
+	return safejson.Marshal(rawType1)
+}
+
+func (a *Type1) UnmarshalJSON(data []byte) error {
+	var rawType1 []Type2
+	if err := safejson.Unmarshal(data, &rawType1); err != nil {
+		return err
+	}
+	*a = Type1(rawType1)
+	return nil
+}
+
+func (a Type1) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *Type1) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type Type2 struct {
 	Value *int
 }
diff --git a/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/foo/aliases.conjure.go b/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/foo/aliases.conjure.go
index 7a6db730..e61299c8 100644
--- a/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/foo/aliases.conjure.go
+++ b/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/foo/aliases.conjure.go
@@ -4,6 +4,41 @@ package foo
 
 import (
 	"github.com/palantir/conjure-go/v6/cycles/testdata/pkg-cycle-disconnected/conjure/com/palantir/fizz"
+	"github.com/palantir/pkg/safejson"
+	"github.com/palantir/pkg/safeyaml"
 )
 
 type Type2 map[fizz.Type1]int
+
+func (a Type2) MarshalJSON() ([]byte, error) {
+	rawType2 := map[fizz.Type1]int(a)
+	if rawType2 == nil {
+		rawType2 = make(map[fizz.Type1]int, 0)
+	}
+	return safejson.Marshal(rawType2)
+}
+
+func (a *Type2) UnmarshalJSON(data []byte) error {
+	var rawType2 map[fizz.Type1]int
+	if err := safejson.Unmarshal(data, &rawType2); err != nil {
+		return err
+	}
+	*a = Type2(rawType2)
+	return nil
+}
+
+func (a Type2) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *Type2) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
diff --git a/cycles/testdata/pkg-cycle/conjure/com/palantir/bar/aliases.conjure.go b/cycles/testdata/pkg-cycle/conjure/com/palantir/bar/aliases.conjure.go
index c7dfdf3d..5b0133f2 100644
--- a/cycles/testdata/pkg-cycle/conjure/com/palantir/bar/aliases.conjure.go
+++ b/cycles/testdata/pkg-cycle/conjure/com/palantir/bar/aliases.conjure.go
@@ -10,7 +10,11 @@ import (
 type Type1 []Type3
 
 func (a Type1) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]Type3(a))
+	rawType1 := []Type3(a)
+	if rawType1 == nil {
+		rawType1 = make([]Type3, 0)
+	}
+	return safejson.Marshal(rawType1)
 }
 
 func (a *Type1) UnmarshalJSON(data []byte) error {
diff --git a/cycles/testdata/pkg-cycle/conjure/com/palantir/foo/aliases.conjure.go b/cycles/testdata/pkg-cycle/conjure/com/palantir/foo/aliases.conjure.go
index 417cc5ed..791a8dbb 100644
--- a/cycles/testdata/pkg-cycle/conjure/com/palantir/foo/aliases.conjure.go
+++ b/cycles/testdata/pkg-cycle/conjure/com/palantir/foo/aliases.conjure.go
@@ -11,7 +11,11 @@ import (
 type Type2 map[fizz.Type1]Type4
 
 func (a Type2) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[fizz.Type1]Type4(a))
+	rawType2 := map[fizz.Type1]Type4(a)
+	if rawType2 == nil {
+		rawType2 = make(map[fizz.Type1]Type4, 0)
+	}
+	return safejson.Marshal(rawType2)
 }
 
 func (a *Type2) UnmarshalJSON(data []byte) error {
diff --git a/cycles/testdata/type-cycle/conjure/com/palantir/bar_foo/aliases.conjure.go b/cycles/testdata/type-cycle/conjure/com/palantir/bar_foo/aliases.conjure.go
index a5dc0855..be1b6f31 100644
--- a/cycles/testdata/type-cycle/conjure/com/palantir/bar_foo/aliases.conjure.go
+++ b/cycles/testdata/type-cycle/conjure/com/palantir/bar_foo/aliases.conjure.go
@@ -11,7 +11,11 @@ import (
 type Type2 map[fizz.Type1]Type4
 
 func (a Type2) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[fizz.Type1]Type4(a))
+	rawType2 := map[fizz.Type1]Type4(a)
+	if rawType2 == nil {
+		rawType2 = make(map[fizz.Type1]Type4, 0)
+	}
+	return safejson.Marshal(rawType2)
 }
 
 func (a *Type2) UnmarshalJSON(data []byte) error {
@@ -42,7 +46,11 @@ func (a *Type2) UnmarshalYAML(unmarshal func(interface{}) error) error {
 type Type1 []BarType3
 
 func (a Type1) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal([]BarType3(a))
+	rawType1 := []BarType3(a)
+	if rawType1 == nil {
+		rawType1 = make([]BarType3, 0)
+	}
+	return safejson.Marshal(rawType1)
 }
 
 func (a *Type1) UnmarshalJSON(data []byte) error {
diff --git a/integration_test/testgenerated/binary/api/aliases.conjure.go b/integration_test/testgenerated/binary/api/aliases.conjure.go
index 4585c78a..8b61ab82 100644
--- a/integration_test/testgenerated/binary/api/aliases.conjure.go
+++ b/integration_test/testgenerated/binary/api/aliases.conjure.go
@@ -128,3 +128,75 @@ func (a *BinaryAliasOptional) UnmarshalYAML(unmarshal func(interface{}) error) e
 	}
 	return safejson.Unmarshal(jsonBytes, *&a)
 }
+
+// requestBodyTestServiceBinaryList provides encoding methods suitable for conjure collections.
+type requestBodyTestServiceBinaryList [][]byte
+
+func (a requestBodyTestServiceBinaryList) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServiceBinaryList := [][]byte(a)
+	if rawrequestBodyTestServiceBinaryList == nil {
+		rawrequestBodyTestServiceBinaryList = make([][]byte, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServiceBinaryList)
+}
+
+func (a *requestBodyTestServiceBinaryList) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServiceBinaryList [][]byte
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServiceBinaryList); err != nil {
+		return err
+	}
+	*a = requestBodyTestServiceBinaryList(rawrequestBodyTestServiceBinaryList)
+	return nil
+}
+
+func (a requestBodyTestServiceBinaryList) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServiceBinaryList) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServiceBinaryList provides encoding methods suitable for conjure collections.
+type responseBodyTestServiceBinaryList [][]byte
+
+func (a responseBodyTestServiceBinaryList) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServiceBinaryList := [][]byte(a)
+	if rawresponseBodyTestServiceBinaryList == nil {
+		rawresponseBodyTestServiceBinaryList = make([][]byte, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServiceBinaryList)
+}
+
+func (a *responseBodyTestServiceBinaryList) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServiceBinaryList [][]byte
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServiceBinaryList); err != nil {
+		return err
+	}
+	*a = responseBodyTestServiceBinaryList(rawresponseBodyTestServiceBinaryList)
+	return nil
+}
+
+func (a responseBodyTestServiceBinaryList) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServiceBinaryList) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
diff --git a/integration_test/testgenerated/binary/api/servers.conjure.go b/integration_test/testgenerated/binary/api/servers.conjure.go
index 5940bb8c..3c8b4b55 100644
--- a/integration_test/testgenerated/binary/api/servers.conjure.go
+++ b/integration_test/testgenerated/binary/api/servers.conjure.go
@@ -146,7 +146,7 @@ func (t *testServiceHandler) HandleBinaryOptionalAlias(rw http.ResponseWriter, r
 
 func (t *testServiceHandler) HandleBinaryList(rw http.ResponseWriter, req *http.Request) error {
 	var bodyArg [][]byte
-	if err := codecs.JSON.Decode(req.Body, &bodyArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServiceBinaryList)(&bodyArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	respArg, err := t.impl.BinaryList(req.Context(), bodyArg)
@@ -154,7 +154,7 @@ func (t *testServiceHandler) HandleBinaryList(rw http.ResponseWriter, req *http.
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServiceBinaryList(respArg))
 }
 
 func (t *testServiceHandler) HandleBytes(rw http.ResponseWriter, req *http.Request) error {
diff --git a/integration_test/testgenerated/binary/api/services.conjure.go b/integration_test/testgenerated/binary/api/services.conjure.go
index 7376113b..a32e2c5c 100644
--- a/integration_test/testgenerated/binary/api/services.conjure.go
+++ b/integration_test/testgenerated/binary/api/services.conjure.go
@@ -134,8 +134,8 @@ func (c *testServiceClient) BinaryList(ctx context.Context, bodyArg [][]byte) ([
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("BinaryList"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("POST"))
 	requestParams = append(requestParams, httpclient.WithPathf("/binaryList"))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServiceBinaryList(bodyArg)))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServiceBinaryList)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "binaryList failed")
 	}
diff --git a/integration_test/testgenerated/cli/api/aliases.conjure.go b/integration_test/testgenerated/cli/api/aliases.conjure.go
index cc740bc3..1b37aa48 100644
--- a/integration_test/testgenerated/cli/api/aliases.conjure.go
+++ b/integration_test/testgenerated/cli/api/aliases.conjure.go
@@ -76,3 +76,291 @@ func (a *OptionalListAlias) UnmarshalYAML(unmarshal func(interface{}) error) err
 }
 
 type StringAlias string
+
+// requestBodyTestServiceEchoStrings provides encoding methods suitable for conjure collections.
+type requestBodyTestServiceEchoStrings []string
+
+func (a requestBodyTestServiceEchoStrings) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServiceEchoStrings := []string(a)
+	if rawrequestBodyTestServiceEchoStrings == nil {
+		rawrequestBodyTestServiceEchoStrings = make([]string, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServiceEchoStrings)
+}
+
+func (a *requestBodyTestServiceEchoStrings) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServiceEchoStrings []string
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServiceEchoStrings); err != nil {
+		return err
+	}
+	*a = requestBodyTestServiceEchoStrings(rawrequestBodyTestServiceEchoStrings)
+	return nil
+}
+
+func (a requestBodyTestServiceEchoStrings) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServiceEchoStrings) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServiceEchoStrings provides encoding methods suitable for conjure collections.
+type responseBodyTestServiceEchoStrings []string
+
+func (a responseBodyTestServiceEchoStrings) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServiceEchoStrings := []string(a)
+	if rawresponseBodyTestServiceEchoStrings == nil {
+		rawresponseBodyTestServiceEchoStrings = make([]string, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServiceEchoStrings)
+}
+
+func (a *responseBodyTestServiceEchoStrings) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServiceEchoStrings []string
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServiceEchoStrings); err != nil {
+		return err
+	}
+	*a = responseBodyTestServiceEchoStrings(rawresponseBodyTestServiceEchoStrings)
+	return nil
+}
+
+func (a responseBodyTestServiceEchoStrings) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServiceEchoStrings) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServiceGetListBoolean provides encoding methods suitable for conjure collections.
+type responseBodyTestServiceGetListBoolean []bool
+
+func (a responseBodyTestServiceGetListBoolean) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServiceGetListBoolean := []bool(a)
+	if rawresponseBodyTestServiceGetListBoolean == nil {
+		rawresponseBodyTestServiceGetListBoolean = make([]bool, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServiceGetListBoolean)
+}
+
+func (a *responseBodyTestServiceGetListBoolean) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServiceGetListBoolean []bool
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServiceGetListBoolean); err != nil {
+		return err
+	}
+	*a = responseBodyTestServiceGetListBoolean(rawresponseBodyTestServiceGetListBoolean)
+	return nil
+}
+
+func (a responseBodyTestServiceGetListBoolean) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServiceGetListBoolean) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// requestBodyTestServicePutMapStringString provides encoding methods suitable for conjure collections.
+type requestBodyTestServicePutMapStringString map[string]string
+
+func (a requestBodyTestServicePutMapStringString) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServicePutMapStringString := map[string]string(a)
+	if rawrequestBodyTestServicePutMapStringString == nil {
+		rawrequestBodyTestServicePutMapStringString = make(map[string]string, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServicePutMapStringString)
+}
+
+func (a *requestBodyTestServicePutMapStringString) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServicePutMapStringString map[string]string
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServicePutMapStringString); err != nil {
+		return err
+	}
+	*a = requestBodyTestServicePutMapStringString(rawrequestBodyTestServicePutMapStringString)
+	return nil
+}
+
+func (a requestBodyTestServicePutMapStringString) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServicePutMapStringString) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServicePutMapStringString provides encoding methods suitable for conjure collections.
+type responseBodyTestServicePutMapStringString map[string]string
+
+func (a responseBodyTestServicePutMapStringString) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServicePutMapStringString := map[string]string(a)
+	if rawresponseBodyTestServicePutMapStringString == nil {
+		rawresponseBodyTestServicePutMapStringString = make(map[string]string, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServicePutMapStringString)
+}
+
+func (a *responseBodyTestServicePutMapStringString) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServicePutMapStringString map[string]string
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServicePutMapStringString); err != nil {
+		return err
+	}
+	*a = responseBodyTestServicePutMapStringString(rawresponseBodyTestServicePutMapStringString)
+	return nil
+}
+
+func (a responseBodyTestServicePutMapStringString) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServicePutMapStringString) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// requestBodyTestServicePutMapStringAny provides encoding methods suitable for conjure collections.
+type requestBodyTestServicePutMapStringAny map[string]interface{}
+
+func (a requestBodyTestServicePutMapStringAny) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServicePutMapStringAny := map[string]interface{}(a)
+	if rawrequestBodyTestServicePutMapStringAny == nil {
+		rawrequestBodyTestServicePutMapStringAny = make(map[string]interface{}, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServicePutMapStringAny)
+}
+
+func (a *requestBodyTestServicePutMapStringAny) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServicePutMapStringAny map[string]interface{}
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServicePutMapStringAny); err != nil {
+		return err
+	}
+	*a = requestBodyTestServicePutMapStringAny(rawrequestBodyTestServicePutMapStringAny)
+	return nil
+}
+
+func (a requestBodyTestServicePutMapStringAny) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServicePutMapStringAny) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServicePutMapStringAny provides encoding methods suitable for conjure collections.
+type responseBodyTestServicePutMapStringAny map[string]interface{}
+
+func (a responseBodyTestServicePutMapStringAny) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServicePutMapStringAny := map[string]interface{}(a)
+	if rawresponseBodyTestServicePutMapStringAny == nil {
+		rawresponseBodyTestServicePutMapStringAny = make(map[string]interface{}, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServicePutMapStringAny)
+}
+
+func (a *responseBodyTestServicePutMapStringAny) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServicePutMapStringAny map[string]interface{}
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServicePutMapStringAny); err != nil {
+		return err
+	}
+	*a = responseBodyTestServicePutMapStringAny(rawresponseBodyTestServicePutMapStringAny)
+	return nil
+}
+
+func (a responseBodyTestServicePutMapStringAny) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServicePutMapStringAny) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// requestBodyTestServiceChan provides encoding methods suitable for conjure collections.
+type requestBodyTestServiceChan map[string]string
+
+func (a requestBodyTestServiceChan) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServiceChan := map[string]string(a)
+	if rawrequestBodyTestServiceChan == nil {
+		rawrequestBodyTestServiceChan = make(map[string]string, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServiceChan)
+}
+
+func (a *requestBodyTestServiceChan) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServiceChan map[string]string
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServiceChan); err != nil {
+		return err
+	}
+	*a = requestBodyTestServiceChan(rawrequestBodyTestServiceChan)
+	return nil
+}
+
+func (a requestBodyTestServiceChan) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServiceChan) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
diff --git a/integration_test/testgenerated/cli/api/servers.conjure.go b/integration_test/testgenerated/cli/api/servers.conjure.go
index 7b668fdd..0d762991 100644
--- a/integration_test/testgenerated/cli/api/servers.conjure.go
+++ b/integration_test/testgenerated/cli/api/servers.conjure.go
@@ -136,7 +136,7 @@ func (t *testServiceHandler) HandleEcho(rw http.ResponseWriter, req *http.Reques
 
 func (t *testServiceHandler) HandleEchoStrings(rw http.ResponseWriter, req *http.Request) error {
 	var bodyArg []string
-	if err := codecs.JSON.Decode(req.Body, &bodyArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServiceEchoStrings)(&bodyArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	respArg, err := t.impl.EchoStrings(req.Context(), bodyArg)
@@ -144,7 +144,7 @@ func (t *testServiceHandler) HandleEchoStrings(rw http.ResponseWriter, req *http
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServiceEchoStrings(respArg))
 }
 
 func (t *testServiceHandler) HandleEchoCustomObject(rw http.ResponseWriter, req *http.Request) error {
@@ -238,12 +238,12 @@ func (t *testServiceHandler) HandleGetListBoolean(rw http.ResponseWriter, req *h
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServiceGetListBoolean(respArg))
 }
 
 func (t *testServiceHandler) HandlePutMapStringString(rw http.ResponseWriter, req *http.Request) error {
 	var myParamArg map[string]string
-	if err := codecs.JSON.Decode(req.Body, &myParamArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServicePutMapStringString)(&myParamArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	respArg, err := t.impl.PutMapStringString(req.Context(), myParamArg)
@@ -251,12 +251,12 @@ func (t *testServiceHandler) HandlePutMapStringString(rw http.ResponseWriter, re
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServicePutMapStringString(respArg))
 }
 
 func (t *testServiceHandler) HandlePutMapStringAny(rw http.ResponseWriter, req *http.Request) error {
 	var myParamArg map[string]interface{}
-	if err := codecs.JSON.Decode(req.Body, &myParamArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServicePutMapStringAny)(&myParamArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	respArg, err := t.impl.PutMapStringAny(req.Context(), myParamArg)
@@ -264,7 +264,7 @@ func (t *testServiceHandler) HandlePutMapStringAny(rw http.ResponseWriter, req *
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServicePutMapStringAny(respArg))
 }
 
 func (t *testServiceHandler) HandleGetDateTime(rw http.ResponseWriter, req *http.Request) error {
@@ -410,7 +410,7 @@ func (t *testServiceHandler) HandleChan(rw http.ResponseWriter, req *http.Reques
 		return werror.WrapWithContextParams(req.Context(), errors.WrapWithInvalidArgument(err), "failed to parse \"return\" as safelong")
 	}
 	var importArg map[string]string
-	if err := codecs.JSON.Decode(req.Body, &importArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServiceChan)(&importArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	if err := t.impl.Chan(req.Context(), varArg, importArg, typeArg, returnArg, httpArg, jsonArg, reqArg, rwArg); err != nil {
diff --git a/integration_test/testgenerated/cli/api/services.conjure.go b/integration_test/testgenerated/cli/api/services.conjure.go
index 222e129b..7db27451 100644
--- a/integration_test/testgenerated/cli/api/services.conjure.go
+++ b/integration_test/testgenerated/cli/api/services.conjure.go
@@ -70,8 +70,8 @@ func (c *testServiceClient) EchoStrings(ctx context.Context, bodyArg []string) (
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoStrings"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("POST"))
 	requestParams = append(requestParams, httpclient.WithPathf("/echo"))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServiceEchoStrings(bodyArg)))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServiceEchoStrings)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "echoStrings failed")
 	}
@@ -154,7 +154,7 @@ func (c *testServiceClient) GetListBoolean(ctx context.Context, myQueryParam1Arg
 		queryParams.Add("myQueryParam1", fmt.Sprint(v))
 	}
 	requestParams = append(requestParams, httpclient.WithQueryValues(queryParams))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServiceGetListBoolean)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "getListBoolean failed")
 	}
@@ -170,8 +170,8 @@ func (c *testServiceClient) PutMapStringString(ctx context.Context, myParamArg m
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("PutMapStringString"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("PUT"))
 	requestParams = append(requestParams, httpclient.WithPathf("/mapStringString"))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(myParamArg))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServicePutMapStringString(myParamArg)))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServicePutMapStringString)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "putMapStringString failed")
 	}
@@ -187,8 +187,8 @@ func (c *testServiceClient) PutMapStringAny(ctx context.Context, myParamArg map[
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("PutMapStringAny"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("PUT"))
 	requestParams = append(requestParams, httpclient.WithPathf("/mapStringAny"))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(myParamArg))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServicePutMapStringAny(myParamArg)))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServicePutMapStringAny)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "putMapStringAny failed")
 	}
@@ -386,7 +386,7 @@ func (c *testServiceClient) Chan(ctx context.Context, varArg string, importArg m
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("Chan"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("POST"))
 	requestParams = append(requestParams, httpclient.WithPathf("/chan/%s", url.PathEscape(fmt.Sprint(varArg))))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(importArg))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServiceChan(importArg)))
 	requestParams = append(requestParams, httpclient.WithHeader("X-My-Header2", fmt.Sprint(returnArg)))
 	queryParams := make(url.Values)
 	queryParams.Set("type", fmt.Sprint(typeArg))
diff --git a/integration_test/testgenerated/objects/api/aliases.conjure.go b/integration_test/testgenerated/objects/api/aliases.conjure.go
index 4f196bb8..cc011730 100644
--- a/integration_test/testgenerated/objects/api/aliases.conjure.go
+++ b/integration_test/testgenerated/objects/api/aliases.conjure.go
@@ -11,6 +11,7 @@ import (
 )
 
 type AnyAlias interface{}
+
 type BinaryAlias []byte
 
 func (a BinaryAlias) String() string {
@@ -47,14 +48,155 @@ func (a *BinaryAlias) UnmarshalYAML(unmarshal func(interface{}) error) error {
 }
 
 type ListLongAlias []interface{}
+
+func (a ListLongAlias) MarshalJSON() ([]byte, error) {
+	rawListLongAlias := []interface{}(a)
+	if rawListLongAlias == nil {
+		rawListLongAlias = make([]interface{}, 0)
+	}
+	return safejson.Marshal(rawListLongAlias)
+}
+
+func (a *ListLongAlias) UnmarshalJSON(data []byte) error {
+	var rawListLongAlias []interface{}
+	if err := safejson.Unmarshal(data, &rawListLongAlias); err != nil {
+		return err
+	}
+	*a = ListLongAlias(rawListLongAlias)
+	return nil
+}
+
+func (a ListLongAlias) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *ListLongAlias) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type LongAlias interface{}
+
 type MapLongAlias map[string]interface{}
+
+func (a MapLongAlias) MarshalJSON() ([]byte, error) {
+	rawMapLongAlias := map[string]interface{}(a)
+	if rawMapLongAlias == nil {
+		rawMapLongAlias = make(map[string]interface{}, 0)
+	}
+	return safejson.Marshal(rawMapLongAlias)
+}
+
+func (a *MapLongAlias) UnmarshalJSON(data []byte) error {
+	var rawMapLongAlias map[string]interface{}
+	if err := safejson.Unmarshal(data, &rawMapLongAlias); err != nil {
+		return err
+	}
+	*a = MapLongAlias(rawMapLongAlias)
+	return nil
+}
+
+func (a MapLongAlias) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapLongAlias) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapStringAny map[string]interface{}
+
+func (a MapStringAny) MarshalJSON() ([]byte, error) {
+	rawMapStringAny := map[string]interface{}(a)
+	if rawMapStringAny == nil {
+		rawMapStringAny = make(map[string]interface{}, 0)
+	}
+	return safejson.Marshal(rawMapStringAny)
+}
+
+func (a *MapStringAny) UnmarshalJSON(data []byte) error {
+	var rawMapStringAny map[string]interface{}
+	if err := safejson.Unmarshal(data, &rawMapStringAny); err != nil {
+		return err
+	}
+	*a = MapStringAny(rawMapStringAny)
+	return nil
+}
+
+func (a MapStringAny) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapStringAny) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapStringAnyAlias map[string]AnyAlias
+
+func (a MapStringAnyAlias) MarshalJSON() ([]byte, error) {
+	rawMapStringAnyAlias := map[string]AnyAlias(a)
+	if rawMapStringAnyAlias == nil {
+		rawMapStringAnyAlias = make(map[string]AnyAlias, 0)
+	}
+	return safejson.Marshal(rawMapStringAnyAlias)
+}
+
+func (a *MapStringAnyAlias) UnmarshalJSON(data []byte) error {
+	var rawMapStringAnyAlias map[string]AnyAlias
+	if err := safejson.Unmarshal(data, &rawMapStringAnyAlias); err != nil {
+		return err
+	}
+	*a = MapStringAnyAlias(rawMapStringAnyAlias)
+	return nil
+}
+
+func (a MapStringAnyAlias) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *MapStringAnyAlias) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
 type MapUuidLongAlias map[uuid.UUID]interface{}
 
 func (a MapUuidLongAlias) MarshalJSON() ([]byte, error) {
-	return safejson.Marshal(map[uuid.UUID]interface{}(a))
+	rawMapUuidLongAlias := map[uuid.UUID]interface{}(a)
+	if rawMapUuidLongAlias == nil {
+		rawMapUuidLongAlias = make(map[uuid.UUID]interface{}, 0)
+	}
+	return safejson.Marshal(rawMapUuidLongAlias)
 }
 
 func (a *MapUuidLongAlias) UnmarshalJSON(data []byte) error {
@@ -83,7 +225,9 @@ func (a *MapUuidLongAlias) UnmarshalYAML(unmarshal func(interface{}) error) erro
 }
 
 type NestedAlias1 NestedAlias2
+
 type NestedAlias2 NestedAlias3
+
 type NestedAlias3 struct {
 	Value *string
 }
@@ -235,7 +379,9 @@ func (a *RidAlias) UnmarshalYAML(unmarshal func(interface{}) error) error {
 }
 
 type StringAlias string
+
 type StringAliasAlias StringAlias
+
 type UuidAlias uuid.UUID
 
 func (a UuidAlias) String() string {
diff --git a/integration_test/testgenerated/server/api/aliases.conjure.go b/integration_test/testgenerated/server/api/aliases.conjure.go
index fe5a11ac..2ac6ab18 100644
--- a/integration_test/testgenerated/server/api/aliases.conjure.go
+++ b/integration_test/testgenerated/server/api/aliases.conjure.go
@@ -3,6 +3,7 @@
 package api
 
 import (
+	"github.com/palantir/pkg/datetime"
 	"github.com/palantir/pkg/safejson"
 	"github.com/palantir/pkg/safeyaml"
 	"github.com/palantir/pkg/uuid"
@@ -112,3 +113,147 @@ func (a *SafeUuid) UnmarshalYAML(unmarshal func(interface{}) error) error {
 }
 
 type StringAlias string
+
+// requestBodyTestServiceEchoStrings provides encoding methods suitable for conjure collections.
+type requestBodyTestServiceEchoStrings []string
+
+func (a requestBodyTestServiceEchoStrings) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServiceEchoStrings := []string(a)
+	if rawrequestBodyTestServiceEchoStrings == nil {
+		rawrequestBodyTestServiceEchoStrings = make([]string, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServiceEchoStrings)
+}
+
+func (a *requestBodyTestServiceEchoStrings) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServiceEchoStrings []string
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServiceEchoStrings); err != nil {
+		return err
+	}
+	*a = requestBodyTestServiceEchoStrings(rawrequestBodyTestServiceEchoStrings)
+	return nil
+}
+
+func (a requestBodyTestServiceEchoStrings) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServiceEchoStrings) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServiceEchoStrings provides encoding methods suitable for conjure collections.
+type responseBodyTestServiceEchoStrings []string
+
+func (a responseBodyTestServiceEchoStrings) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServiceEchoStrings := []string(a)
+	if rawresponseBodyTestServiceEchoStrings == nil {
+		rawresponseBodyTestServiceEchoStrings = make([]string, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServiceEchoStrings)
+}
+
+func (a *responseBodyTestServiceEchoStrings) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServiceEchoStrings []string
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServiceEchoStrings); err != nil {
+		return err
+	}
+	*a = responseBodyTestServiceEchoStrings(rawresponseBodyTestServiceEchoStrings)
+	return nil
+}
+
+func (a responseBodyTestServiceEchoStrings) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServiceEchoStrings) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// responseBodyTestServiceQueryParamSetDateTime provides encoding methods suitable for conjure collections.
+type responseBodyTestServiceQueryParamSetDateTime []datetime.DateTime
+
+func (a responseBodyTestServiceQueryParamSetDateTime) MarshalJSON() ([]byte, error) {
+	rawresponseBodyTestServiceQueryParamSetDateTime := []datetime.DateTime(a)
+	if rawresponseBodyTestServiceQueryParamSetDateTime == nil {
+		rawresponseBodyTestServiceQueryParamSetDateTime = make([]datetime.DateTime, 0)
+	}
+	return safejson.Marshal(rawresponseBodyTestServiceQueryParamSetDateTime)
+}
+
+func (a *responseBodyTestServiceQueryParamSetDateTime) UnmarshalJSON(data []byte) error {
+	var rawresponseBodyTestServiceQueryParamSetDateTime []datetime.DateTime
+	if err := safejson.Unmarshal(data, &rawresponseBodyTestServiceQueryParamSetDateTime); err != nil {
+		return err
+	}
+	*a = responseBodyTestServiceQueryParamSetDateTime(rawresponseBodyTestServiceQueryParamSetDateTime)
+	return nil
+}
+
+func (a responseBodyTestServiceQueryParamSetDateTime) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *responseBodyTestServiceQueryParamSetDateTime) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
+
+// requestBodyTestServiceChan provides encoding methods suitable for conjure collections.
+type requestBodyTestServiceChan map[string]string
+
+func (a requestBodyTestServiceChan) MarshalJSON() ([]byte, error) {
+	rawrequestBodyTestServiceChan := map[string]string(a)
+	if rawrequestBodyTestServiceChan == nil {
+		rawrequestBodyTestServiceChan = make(map[string]string, 0)
+	}
+	return safejson.Marshal(rawrequestBodyTestServiceChan)
+}
+
+func (a *requestBodyTestServiceChan) UnmarshalJSON(data []byte) error {
+	var rawrequestBodyTestServiceChan map[string]string
+	if err := safejson.Unmarshal(data, &rawrequestBodyTestServiceChan); err != nil {
+		return err
+	}
+	*a = requestBodyTestServiceChan(rawrequestBodyTestServiceChan)
+	return nil
+}
+
+func (a requestBodyTestServiceChan) MarshalYAML() (interface{}, error) {
+	jsonBytes, err := safejson.Marshal(a)
+	if err != nil {
+		return nil, err
+	}
+	return safeyaml.JSONtoYAMLMapSlice(jsonBytes)
+}
+
+func (a *requestBodyTestServiceChan) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	jsonBytes, err := safeyaml.UnmarshalerToJSONBytes(unmarshal)
+	if err != nil {
+		return err
+	}
+	return safejson.Unmarshal(jsonBytes, *&a)
+}
diff --git a/integration_test/testgenerated/server/api/servers.conjure.go b/integration_test/testgenerated/server/api/servers.conjure.go
index 476f68ec..dc8f5860 100644
--- a/integration_test/testgenerated/server/api/servers.conjure.go
+++ b/integration_test/testgenerated/server/api/servers.conjure.go
@@ -170,7 +170,7 @@ func (t *testServiceHandler) HandleEcho(rw http.ResponseWriter, req *http.Reques
 
 func (t *testServiceHandler) HandleEchoStrings(rw http.ResponseWriter, req *http.Request) error {
 	var bodyArg []string
-	if err := codecs.JSON.Decode(req.Body, &bodyArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServiceEchoStrings)(&bodyArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	respArg, err := t.impl.EchoStrings(req.Context(), bodyArg)
@@ -178,7 +178,7 @@ func (t *testServiceHandler) HandleEchoStrings(rw http.ResponseWriter, req *http
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServiceEchoStrings(respArg))
 }
 
 func (t *testServiceHandler) HandleEchoCustomObject(rw http.ResponseWriter, req *http.Request) error {
@@ -350,7 +350,7 @@ func (t *testServiceHandler) HandleQueryParamSetDateTime(rw http.ResponseWriter,
 		return err
 	}
 	rw.Header().Add("Content-Type", codecs.JSON.ContentType())
-	return codecs.JSON.Encode(rw, respArg)
+	return codecs.JSON.Encode(rw, responseBodyTestServiceQueryParamSetDateTime(respArg))
 }
 
 func (t *testServiceHandler) HandleQueryParamListDouble(rw http.ResponseWriter, req *http.Request) error {
@@ -746,7 +746,7 @@ func (t *testServiceHandler) HandleChan(rw http.ResponseWriter, req *http.Reques
 		return werror.WrapWithContextParams(req.Context(), errors.WrapWithInvalidArgument(err), "failed to parse \"return\" as safelong")
 	}
 	var importArg map[string]string
-	if err := codecs.JSON.Decode(req.Body, &importArg); err != nil {
+	if err := codecs.JSON.Decode(req.Body, (*requestBodyTestServiceChan)(&importArg)); err != nil {
 		return errors.WrapWithInvalidArgument(err)
 	}
 	if err := t.impl.Chan(req.Context(), varArg, importArg, typeArg, returnArg, httpArg, jsonArg, reqArg, rwArg); err != nil {
diff --git a/integration_test/testgenerated/server/api/services.conjure.go b/integration_test/testgenerated/server/api/services.conjure.go
index 86dc76ee..3cf2cdeb 100644
--- a/integration_test/testgenerated/server/api/services.conjure.go
+++ b/integration_test/testgenerated/server/api/services.conjure.go
@@ -77,8 +77,8 @@ func (c *testServiceClient) EchoStrings(ctx context.Context, bodyArg []string) (
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("EchoStrings"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("POST"))
 	requestParams = append(requestParams, httpclient.WithPathf("/echo"))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(bodyArg))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServiceEchoStrings(bodyArg)))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServiceEchoStrings)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "echoStrings failed")
 	}
@@ -225,7 +225,7 @@ func (c *testServiceClient) QueryParamSetDateTime(ctx context.Context, authHeade
 		queryParams.Add("myQueryParam1", fmt.Sprint(v))
 	}
 	requestParams = append(requestParams, httpclient.WithQueryValues(queryParams))
-	requestParams = append(requestParams, httpclient.WithJSONResponse(&returnVal))
+	requestParams = append(requestParams, httpclient.WithJSONResponse((*responseBodyTestServiceQueryParamSetDateTime)(&returnVal)))
 	if _, err := c.client.Do(ctx, requestParams...); err != nil {
 		return nil, werror.WrapWithContextParams(ctx, err, "queryParamSetDateTime failed")
 	}
@@ -533,7 +533,7 @@ func (c *testServiceClient) Chan(ctx context.Context, varArg string, importArg m
 	requestParams = append(requestParams, httpclient.WithRPCMethodName("Chan"))
 	requestParams = append(requestParams, httpclient.WithRequestMethod("POST"))
 	requestParams = append(requestParams, httpclient.WithPathf("/chan/%s", url.PathEscape(fmt.Sprint(varArg))))
-	requestParams = append(requestParams, httpclient.WithJSONRequest(importArg))
+	requestParams = append(requestParams, httpclient.WithJSONRequest(requestBodyTestServiceChan(importArg)))
 	requestParams = append(requestParams, httpclient.WithHeader("X-My-Header2", fmt.Sprint(returnArg)))
 	queryParams := make(url.Values)
 	queryParams.Set("type", fmt.Sprint(typeArg))
diff --git a/integration_test/testgenerated/server/server_test.go b/integration_test/testgenerated/server/server_test.go
index 6af8e406..45fa3cb4 100644
--- a/integration_test/testgenerated/server/server_test.go
+++ b/integration_test/testgenerated/server/server_test.go
@@ -260,6 +260,29 @@ func TestEchoQueryParamSet(t *testing.T) {
 	require.Equal(t, req, out)
 }
 
+func TestEchoStrings(t *testing.T) {
+	wlog.SetDefaultLoggerProvider(wlog.NewJSONMarshalLoggerProvider())
+	router := wrouter.New(whttprouter.New())
+	err := api.RegisterRoutesTestService(router, testServerImpl{})
+	require.NoError(t, err)
+	server := httptest.NewServer(router)
+	defer server.Close()
+	client := api.NewTestServiceClient(newHTTPClient(t, server.URL))
+
+	t.Run("values", func(t *testing.T) {
+		req := []string{"1", "2", "3"}
+		out, err := client.EchoStrings(context.Background(), req)
+		require.NoError(t, err)
+		require.Equal(t, req, out)
+	})
+
+	t.Run("nil", func(t *testing.T) {
+		empty, err := client.EchoStrings(context.Background(), nil)
+		require.NoError(t, err)
+		require.Equal(t, []string{}, empty, "expected server to marshal [] for null input")
+	})
+}
+
 type testServerImpl struct{}
 
 func (t testServerImpl) PostSafeParams(ctx context.Context, authHeader bearertoken.Token, myPathParam1Arg string, myPathParam2Arg bool, myBodyParamArg api.CustomObject, myQueryParam1Arg string, myQueryParam2Arg string,
@@ -296,7 +319,7 @@ func (t testServerImpl) Echo(ctx context.Context, cookieToken bearertoken.Token)
 }
 
 func (t testServerImpl) EchoStrings(ctx context.Context, bodyArg []string) ([]string, error) {
-	panic("implement me")
+	return bodyArg, nil
 }
 
 func (t testServerImpl) EchoCustomObject(ctx context.Context, bodyArg *api.CustomObject) (*api.CustomObject, error) {