func (d DotFishMarket) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populate(objectMap, "fishes", d.Fishes)
	populate(objectMap, "salmons", d.Salmons)
	populate(objectMap, "sampleFish", d.SampleFish)
	populate(objectMap, "sampleSalmon", d.SampleSalmon)
	return json.Marshal(objectMap)
}
MarshalJSON implements the json.Marshaller interface for type DotFishMarket.
package complexgroup
import (
	"encoding/json"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"reflect"
	"time"
)
type ArrayGetEmptyOptions struct {
}
type ArrayGetNotProvidedOptions struct {
}
type ArrayGetValidOptions struct {
}
type ArrayPutEmptyOptions struct {
}
type ArrayPutValidOptions struct {
}
type ArrayWrapper struct {
	Array []*string `json:"array,omitempty"`
}
func (a ArrayWrapper) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populate(objectMap, "array", a.Array)
	return json.Marshal(objectMap)
}
type Basic struct {
	Color *CMYKColors `json:"color,omitempty"`
	ID *int32 `json:"id,omitempty"`
	Name *string `json:"name,omitempty"`
}
type BasicGetEmptyOptions struct {
}
type BasicGetInvalidOptions struct {
}
type BasicGetNotProvidedOptions struct {
}
type BasicGetNullOptions struct {
}
type BasicGetValidOptions struct {
}
type BasicPutValidOptions struct {
}
type BooleanWrapper struct {
	FieldFalse *bool `json:"field_false,omitempty"`
	FieldTrue  *bool `json:"field_true,omitempty"`
}
type ByteWrapper struct {
	Field []byte `json:"field,omitempty"`
}
func (b ByteWrapper) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populateByteArray(objectMap, "field", b.Field, runtime.Base64StdFormat)
	return json.Marshal(objectMap)
}
func (b *ByteWrapper) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return err
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "field":
			err = runtime.DecodeByteArray(string(val), &b.Field, runtime.Base64StdFormat)
			delete(rawMsg, key)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
type Cat struct {
	Pet
	Color *string `json:"color,omitempty"`
	Hates []*Dog  `json:"hates,omitempty"`
}
func (c Cat) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	c.marshalInternal(objectMap)
	return json.Marshal(objectMap)
}
func (c Cat) marshalInternal(objectMap map[string]interface{}) {
	c.Pet.marshalInternal(objectMap)
	populate(objectMap, "color", c.Color)
	populate(objectMap, "hates", c.Hates)
}
type Cookiecuttershark struct {
	Shark
}
func (c Cookiecuttershark) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	c.Shark.marshalInternal(objectMap, "cookiecuttershark")
	return json.Marshal(objectMap)
}
type DateWrapper struct {
	Field *time.Time `json:"field,omitempty"`
	Leap  *time.Time `json:"leap,omitempty"`
}
func (d DateWrapper) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populateDateType(objectMap, "field", d.Field)
	populateDateType(objectMap, "leap", d.Leap)
	return json.Marshal(objectMap)
}
func (d *DateWrapper) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return err
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "field":
			err = unpopulateDateType(val, &d.Field)
			delete(rawMsg, key)
		case "leap":
			err = unpopulateDateType(val, &d.Leap)
			delete(rawMsg, key)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
type DatetimeWrapper struct {
	Field *time.Time `json:"field,omitempty"`
	Now   *time.Time `json:"now,omitempty"`
}
func (d DatetimeWrapper) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populateTimeRFC3339(objectMap, "field", d.Field)
	populateTimeRFC3339(objectMap, "now", d.Now)
	return json.Marshal(objectMap)
}
func (d *DatetimeWrapper) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return err
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "field":
			err = unpopulateTimeRFC3339(val, &d.Field)
			delete(rawMsg, key)
		case "now":
			err = unpopulateTimeRFC3339(val, &d.Now)
			delete(rawMsg, key)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
type Datetimerfc1123Wrapper struct {
	Field *time.Time `json:"field,omitempty"`
	Now   *time.Time `json:"now,omitempty"`
}
func (d Datetimerfc1123Wrapper) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populateTimeRFC1123(objectMap, "field", d.Field)
	populateTimeRFC1123(objectMap, "now", d.Now)
	return json.Marshal(objectMap)
}
func (d *Datetimerfc1123Wrapper) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return err
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "field":
			err = unpopulateTimeRFC1123(val, &d.Field)
			delete(rawMsg, key)
		case "now":
			err = unpopulateTimeRFC1123(val, &d.Now)
			delete(rawMsg, key)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
type DictionaryGetEmptyOptions struct {
}
type DictionaryGetNotProvidedOptions struct {
}
type DictionaryGetNullOptions struct {
}
type DictionaryGetValidOptions struct {
}
type DictionaryPutEmptyOptions struct {
}
type DictionaryPutValidOptions struct {
}
type DictionaryWrapper struct {
	DefaultProgram map[string]*string `json:"defaultProgram,omitempty"`
}
func (d DictionaryWrapper) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	populate(objectMap, "defaultProgram", d.DefaultProgram)
	return json.Marshal(objectMap)
}
type Dog struct {
	Pet
	Food *string `json:"food,omitempty"`
}
func (d Dog) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]interface{})
	d.Pet.marshalInternal(objectMap)
	populate(objectMap, "food", d.Food)
	return json.Marshal(objectMap)
}
type DotFishClassification interface {
	GetDotFish() *DotFish
}
type DotFish struct {
	FishType *string `json:"fish.type,omitempty"`
	Species  *string `json:"species,omitempty"`
}
func (d *DotFish) GetDotFish() *DotFish { return d }
func (d *DotFish) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return err
	}
	return d.unmarshalInternal(rawMsg)
}
func (d DotFish) marshalInternal(objectMap map[string]interface{}, discValue string) {
	d.FishType = &discValue
	objectMap["fish.type"] = d.FishType
	populate(objectMap, "species", d.Species)
}
func (d *DotFish) unmarshalInternal(rawMsg map[string]json.RawMessage) error {
	for key, val := range rawMsg {
		var err error
		switch key {
		case "fish.type":
			err = unpopulate(val, &d.FishType)
			delete(rawMsg, key)
		case "species":
			err = unpopulate(val, &d.Species)
			delete(rawMsg, key)
		}
		if err != nil {
			return err
		}
	}
	return nil
}
type DotFishMarket struct {
	Fishes       []DotFishClassification `json:"fishes,omitempty"`
	Salmons      []*DotSalmon            `json:"salmons,omitempty"`
	SampleFish   DotFishClassification   `json:"sampleFish,omitempty"`
	SampleSalmon *DotSalmon              `json:"sampleSalmon,omitempty"`
}