func (s Slide) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias Slide
	aux := &struct {
		*alias
		Items *[]*string `xml:"item"`
	}{
		alias: (*alias)(&s),
	}
	if s.Items != nil {
		aux.Items = &s.Items
	}
	return e.EncodeElement(aux, start)
}
MarshalXML implements the xml.Marshaller interface for type Slide.
package xmlgroup
import (
	"encoding/xml"
	"time"
)
type AccessPolicy struct {
	Expiry *time.Time `xml:"Expiry"`
	Permission *string `xml:"Permission"`
	Start *time.Time `xml:"Start"`
}
func (a AccessPolicy) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias AccessPolicy
	aux := &struct {
		*alias
		Expiry *timeRFC3339 `xml:"Expiry"`
		Start  *timeRFC3339 `xml:"Start"`
	}{
		alias:  (*alias)(&a),
		Expiry: (*timeRFC3339)(a.Expiry),
		Start:  (*timeRFC3339)(a.Start),
	}
	return e.EncodeElement(aux, start)
}
func (a *AccessPolicy) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	type alias AccessPolicy
	aux := &struct {
		*alias
		Expiry *timeRFC3339 `xml:"Expiry"`
		Start  *timeRFC3339 `xml:"Start"`
	}{
		alias: (*alias)(a),
	}
	if err := d.DecodeElement(aux, &start); err != nil {
		return err
	}
	a.Expiry = (*time.Time)(aux.Expiry)
	a.Start = (*time.Time)(aux.Start)
	return nil
}
type AppleBarrel struct {
	BadApples  []*string `xml:"BadApples>Apple"`
	GoodApples []*string `xml:"GoodApples>Apple"`
}
func (a AppleBarrel) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias AppleBarrel
	aux := &struct {
		*alias
		BadApples  *[]*string `xml:"BadApples>Apple"`
		GoodApples *[]*string `xml:"GoodApples>Apple"`
	}{
		alias: (*alias)(&a),
	}
	if a.BadApples != nil {
		aux.BadApples = &a.BadApples
	}
	if a.GoodApples != nil {
		aux.GoodApples = &a.GoodApples
	}
	return e.EncodeElement(aux, start)
}
type Banana struct {
	Expiration *time.Time `xml:"expiration"`
	Flavor     *string    `xml:"flavor"`
	Name       *string    `xml:"name"`
}
func (b Banana) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	start.Name.Local = "banana"
	type alias Banana
	aux := &struct {
		*alias
		Expiration *timeRFC3339 `xml:"expiration"`
	}{
		alias:      (*alias)(&b),
		Expiration: (*timeRFC3339)(b.Expiration),
	}
	return e.EncodeElement(aux, start)
}
func (b *Banana) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	type alias Banana
	aux := &struct {
		*alias
		Expiration *timeRFC3339 `xml:"expiration"`
	}{
		alias: (*alias)(b),
	}
	if err := d.DecodeElement(aux, &start); err != nil {
		return err
	}
	b.Expiration = (*time.Time)(aux.Expiration)
	return nil
}
type Blob struct {
	Deleted *bool `xml:"Deleted"`
	Name *string `xml:"Name"`
	Properties *BlobProperties `xml:"Properties"`
	Snapshot *string `xml:"Snapshot"`
	Metadata map[string]*string `xml:"Metadata"`
}
func (b *Blob) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	type alias Blob
	aux := &struct {
		*alias
		Metadata additionalProperties `xml:"Metadata"`
	}{
		alias: (*alias)(b),
	}
	if err := d.DecodeElement(aux, &start); err != nil {
		return err
	}
	b.Metadata = (map[string]*string)(aux.Metadata)
	return nil
}
type BlobPrefix struct {
	Name *string `xml:"Name"`
}
type BlobProperties struct {
	Etag *string `xml:"Etag"`
	LastModified       *time.Time     `xml:"Last-Modified"`
	AccessTier         *AccessTier    `xml:"AccessTier"`
	AccessTierInferred *bool          `xml:"AccessTierInferred"`
	ArchiveStatus      *ArchiveStatus `xml:"ArchiveStatus"`
	BlobSequenceNumber *int32         `xml:"x-ms-blob-sequence-number"`
	BlobType           *BlobType      `xml:"BlobType"`
	CacheControl       *string        `xml:"Cache-Control"`
	ContentDisposition *string        `xml:"Content-Disposition"`
	ContentEncoding    *string        `xml:"Content-Encoding"`
	ContentLanguage    *string        `xml:"Content-Language"`
	ContentLength          *int64             `xml:"Content-Length"`
	ContentMD5             *string            `xml:"Content-MD5"`
	ContentType            *string            `xml:"Content-Type"`
	CopyCompletionTime     *time.Time         `xml:"CopyCompletionTime"`
	CopyID                 *string            `xml:"CopyId"`
	CopyProgress           *string            `xml:"CopyProgress"`
	CopySource             *string            `xml:"CopySource"`
	CopyStatus             *CopyStatusType    `xml:"CopyStatus"`
	CopyStatusDescription  *string            `xml:"CopyStatusDescription"`
	DeletedTime            *time.Time         `xml:"DeletedTime"`
	DestinationSnapshot    *string            `xml:"DestinationSnapshot"`
	IncrementalCopy        *bool              `xml:"IncrementalCopy"`
	LeaseDuration          *LeaseDurationType `xml:"LeaseDuration"`
	LeaseState             *LeaseStateType    `xml:"LeaseState"`
	LeaseStatus            *LeaseStatusType   `xml:"LeaseStatus"`
	RemainingRetentionDays *int32             `xml:"RemainingRetentionDays"`
	ServerEncrypted        *bool              `xml:"ServerEncrypted"`
}
func (b BlobProperties) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias BlobProperties
	aux := &struct {
		*alias
		CopyCompletionTime *timeRFC1123 `xml:"CopyCompletionTime"`
		DeletedTime        *timeRFC1123 `xml:"DeletedTime"`
		LastModified       *timeRFC1123 `xml:"Last-Modified"`
	}{
		alias:              (*alias)(&b),
		CopyCompletionTime: (*timeRFC1123)(b.CopyCompletionTime),
		DeletedTime:        (*timeRFC1123)(b.DeletedTime),
		LastModified:       (*timeRFC1123)(b.LastModified),
	}
	return e.EncodeElement(aux, start)
}
func (b *BlobProperties) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	type alias BlobProperties
	aux := &struct {
		*alias
		CopyCompletionTime *timeRFC1123 `xml:"CopyCompletionTime"`
		DeletedTime        *timeRFC1123 `xml:"DeletedTime"`
		LastModified       *timeRFC1123 `xml:"Last-Modified"`
	}{
		alias: (*alias)(b),
	}
	if err := d.DecodeElement(aux, &start); err != nil {
		return err
	}
	b.CopyCompletionTime = (*time.Time)(aux.CopyCompletionTime)
	b.DeletedTime = (*time.Time)(aux.DeletedTime)
	b.LastModified = (*time.Time)(aux.LastModified)
	return nil
}
type Blobs struct {
	Blob       []*Blob       `xml:"Blob"`
	BlobPrefix []*BlobPrefix `xml:"BlobPrefix"`
}
func (b Blobs) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias Blobs
	aux := &struct {
		*alias
		Blob       *[]*Blob       `xml:"Blob"`
		BlobPrefix *[]*BlobPrefix `xml:"BlobPrefix"`
	}{
		alias: (*alias)(&b),
	}
	if b.Blob != nil {
		aux.Blob = &b.Blob
	}
	if b.BlobPrefix != nil {
		aux.BlobPrefix = &b.BlobPrefix
	}
	return e.EncodeElement(aux, start)
}
type ComplexTypeNoMeta struct {
	ID *string `xml:"ID"`
}
type ComplexTypeWithMeta struct {
	ID *string `xml:"ID"`
}
type Container struct {
	Name *string `xml:"Name"`
	Properties *ContainerProperties `xml:"Properties"`
	Metadata map[string]*string `xml:"Metadata"`
}
func (c *Container) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	type alias Container
	aux := &struct {
		*alias
		Metadata additionalProperties `xml:"Metadata"`
	}{
		alias: (*alias)(c),
	}
	if err := d.DecodeElement(aux, &start); err != nil {
		return err
	}
	c.Metadata = (map[string]*string)(aux.Metadata)
	return nil
}
type ContainerProperties struct {
	Etag *string `xml:"Etag"`
	LastModified  *time.Time         `xml:"Last-Modified"`
	LeaseDuration *LeaseDurationType `xml:"LeaseDuration"`
	LeaseState    *LeaseStateType    `xml:"LeaseState"`
	LeaseStatus   *LeaseStatusType   `xml:"LeaseStatus"`
	PublicAccess  *PublicAccessType  `xml:"PublicAccess"`
}
func (c ContainerProperties) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias ContainerProperties
	aux := &struct {
		*alias
		LastModified *timeRFC1123 `xml:"Last-Modified"`
	}{
		alias:        (*alias)(&c),
		LastModified: (*timeRFC1123)(c.LastModified),
	}
	return e.EncodeElement(aux, start)
}
func (c *ContainerProperties) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	type alias ContainerProperties
	aux := &struct {
		*alias
		LastModified *timeRFC1123 `xml:"Last-Modified"`
	}{
		alias: (*alias)(c),
	}
	if err := d.DecodeElement(aux, &start); err != nil {
		return err
	}
	c.LastModified = (*time.Time)(aux.LastModified)
	return nil
}
type CorsRule struct {
	AllowedHeaders *string `xml:"AllowedHeaders"`
	AllowedMethods *string `xml:"AllowedMethods"`
	AllowedOrigins *string `xml:"AllowedOrigins"`
	ExposedHeaders *string `xml:"ExposedHeaders"`
	MaxAgeInSeconds *int32 `xml:"MaxAgeInSeconds"`
}
type Error struct {
	raw     string
	Message *string `xml:"message"`
	Status  *int32  `xml:"status"`
}
func (e Error) Error() string {
	return e.raw
}
type JSONInput struct {
	ID *int32 `json:"id,omitempty"`
}
type JSONOutput struct {
	ID *int32 `json:"id,omitempty"`
}
type ListBlobsResponse struct {
	Blobs *Blobs `xml:"Blobs"`
	ContainerName *string `xml:"ContainerName,attr"`
	Delimiter *string `xml:"Delimiter"`
	Marker *string `xml:"Marker"`
	MaxResults *int32 `xml:"MaxResults"`
	NextMarker *string `xml:"NextMarker"`
	Prefix          *string `xml:"Prefix"`
	ServiceEndpoint *string `xml:"ServiceEndpoint,attr"`
}
type ListContainersResponse struct {
	MaxResults *int32 `xml:"MaxResults"`
	NextMarker *string `xml:"NextMarker"`
	Prefix *string `xml:"Prefix"`
	ServiceEndpoint *string      `xml:"ServiceEndpoint,attr"`
	Containers      []*Container `xml:"Containers>Container"`
	Marker          *string      `xml:"Marker"`
}
func (l ListContainersResponse) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias ListContainersResponse
	aux := &struct {
		*alias
		Containers *[]*Container `xml:"Containers>Container"`
	}{
		alias: (*alias)(&l),
	}
	if l.Containers != nil {
		aux.Containers = &l.Containers
	}
	return e.EncodeElement(aux, start)
}
type Logging struct {
	Delete *bool `xml:"Delete"`
	Read *bool `xml:"Read"`
	RetentionPolicy *RetentionPolicy `xml:"RetentionPolicy"`
	Version *string `xml:"Version"`
	Write *bool `xml:"Write"`
}
type Metrics struct {
	Enabled *bool `xml:"Enabled"`
	IncludeAPIs *bool `xml:"IncludeAPIs"`
	RetentionPolicy *RetentionPolicy `xml:"RetentionPolicy"`
	Version *string `xml:"Version"`
}
type ModelWithByteProperty struct {
	Bytes []byte `xml:"Bytes"`
}
func (m ModelWithByteProperty) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	type alias ModelWithByteProperty
	aux := &struct {
		*alias
		Bytes *[]byte `xml:"Bytes"`
	}{
		alias: (*alias)(&m),
	}
	if m.Bytes != nil {
		aux.Bytes = &m.Bytes
	}
	return e.EncodeElement(aux, start)
}
type ModelWithURLProperty struct {
	URL *string `xml:"Url"`
}
type ObjectWithXMsTextProperty struct {
	Content *string `xml:"content"`
	Language *string `xml:"language,attr"`
}
type RetentionPolicy struct {
	Enabled *bool `xml:"Enabled"`
	Days *int32 `xml:"Days"`
}
type RootWithRefAndMeta struct {
	RefToModel *ComplexTypeWithMeta `xml:"XMLComplexTypeWithMeta"`
	Something *string `xml:"Something"`
}
type RootWithRefAndNoMeta struct {
	RefToModel *ComplexTypeNoMeta `xml:"RefToModel"`
	Something *string `xml:"Something"`
}
type SignedIdentifier struct {
	AccessPolicy *AccessPolicy `xml:"AccessPolicy"`
	ID *string `xml:"Id"`
}
type Slide struct {
	Items []*string `xml:"item"`
	Title *string   `xml:"title"`
	Type  *string   `xml:"type,attr"`
}