func (client *XMLClient) GetEmptyRootList(ctx context.Context, options *XMLGetEmptyRootListOptions) (XMLGetEmptyRootListResponse, error) {
	req, err := client.getEmptyRootListCreateRequest(ctx, options)
	if err != nil {
		return XMLGetEmptyRootListResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetEmptyRootListResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetEmptyRootListResponse{}, client.getEmptyRootListHandleError(resp)
	}
	return client.getEmptyRootListHandleResponse(resp)
}
GetEmptyRootList - Gets an empty list as the root element.
If the operation fails it returns a generic error.
package xmlgroup
import (
	"context"
	"encoding/xml"
	"errors"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
)
type XMLClient struct {
	con *Connection
}
func NewXMLClient(con *Connection) *XMLClient {
	return &XMLClient{con: con}
}
func (client *XMLClient) GetACLs(ctx context.Context, options *XMLGetACLsOptions) (XMLGetACLsResponse, error) {
	req, err := client.getACLsCreateRequest(ctx, options)
	if err != nil {
		return XMLGetACLsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetACLsResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetACLsResponse{}, client.getACLsHandleError(resp)
	}
	return client.getACLsHandleResponse(resp)
}
func (client *XMLClient) getACLsCreateRequest(ctx context.Context, options *XMLGetACLsOptions) (*policy.Request, error) {
	urlPath := "/xml/mycontainer"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	reqQP := req.Raw().URL.Query()
	reqQP.Set("comp", "acl")
	reqQP.Set("restype", "container")
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getACLsHandleResponse(resp *http.Response) (XMLGetACLsResponse, error) {
	result := XMLGetACLsResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result); err != nil {
		return XMLGetACLsResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getACLsHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *XMLClient) GetBytes(ctx context.Context, options *XMLGetBytesOptions) (XMLGetBytesResponse, error) {
	req, err := client.getBytesCreateRequest(ctx, options)
	if err != nil {
		return XMLGetBytesResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetBytesResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetBytesResponse{}, client.getBytesHandleError(resp)
	}
	return client.getBytesHandleResponse(resp)
}
func (client *XMLClient) getBytesCreateRequest(ctx context.Context, options *XMLGetBytesOptions) (*policy.Request, error) {
	urlPath := "/xml/bytes"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getBytesHandleResponse(resp *http.Response) (XMLGetBytesResponse, error) {
	result := XMLGetBytesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.ModelWithByteProperty); err != nil {
		return XMLGetBytesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getBytesHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	errType := Error{raw: string(body)}
	if err := runtime.UnmarshalAsXML(resp, &errType); err != nil {
		return runtime.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp)
	}
	return runtime.NewResponseError(&errType, resp)
}
func (client *XMLClient) GetComplexTypeRefNoMeta(ctx context.Context, options *XMLGetComplexTypeRefNoMetaOptions) (XMLGetComplexTypeRefNoMetaResponse, error) {
	req, err := client.getComplexTypeRefNoMetaCreateRequest(ctx, options)
	if err != nil {
		return XMLGetComplexTypeRefNoMetaResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetComplexTypeRefNoMetaResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetComplexTypeRefNoMetaResponse{}, client.getComplexTypeRefNoMetaHandleError(resp)
	}
	return client.getComplexTypeRefNoMetaHandleResponse(resp)
}
func (client *XMLClient) getComplexTypeRefNoMetaCreateRequest(ctx context.Context, options *XMLGetComplexTypeRefNoMetaOptions) (*policy.Request, error) {
	urlPath := "/xml/complex-type-ref-no-meta"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getComplexTypeRefNoMetaHandleResponse(resp *http.Response) (XMLGetComplexTypeRefNoMetaResponse, error) {
	result := XMLGetComplexTypeRefNoMetaResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.RootWithRefAndNoMeta); err != nil {
		return XMLGetComplexTypeRefNoMetaResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getComplexTypeRefNoMetaHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *XMLClient) GetComplexTypeRefWithMeta(ctx context.Context, options *XMLGetComplexTypeRefWithMetaOptions) (XMLGetComplexTypeRefWithMetaResponse, error) {
	req, err := client.getComplexTypeRefWithMetaCreateRequest(ctx, options)
	if err != nil {
		return XMLGetComplexTypeRefWithMetaResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetComplexTypeRefWithMetaResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetComplexTypeRefWithMetaResponse{}, client.getComplexTypeRefWithMetaHandleError(resp)
	}
	return client.getComplexTypeRefWithMetaHandleResponse(resp)
}
func (client *XMLClient) getComplexTypeRefWithMetaCreateRequest(ctx context.Context, options *XMLGetComplexTypeRefWithMetaOptions) (*policy.Request, error) {
	urlPath := "/xml/complex-type-ref-with-meta"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getComplexTypeRefWithMetaHandleResponse(resp *http.Response) (XMLGetComplexTypeRefWithMetaResponse, error) {
	result := XMLGetComplexTypeRefWithMetaResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.RootWithRefAndMeta); err != nil {
		return XMLGetComplexTypeRefWithMetaResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getComplexTypeRefWithMetaHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *XMLClient) GetEmptyChildElement(ctx context.Context, options *XMLGetEmptyChildElementOptions) (XMLGetEmptyChildElementResponse, error) {
	req, err := client.getEmptyChildElementCreateRequest(ctx, options)
	if err != nil {
		return XMLGetEmptyChildElementResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetEmptyChildElementResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetEmptyChildElementResponse{}, client.getEmptyChildElementHandleError(resp)
	}
	return client.getEmptyChildElementHandleResponse(resp)
}
func (client *XMLClient) getEmptyChildElementCreateRequest(ctx context.Context, options *XMLGetEmptyChildElementOptions) (*policy.Request, error) {
	urlPath := "/xml/empty-child-element"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getEmptyChildElementHandleResponse(resp *http.Response) (XMLGetEmptyChildElementResponse, error) {
	result := XMLGetEmptyChildElementResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.Banana); err != nil {
		return XMLGetEmptyChildElementResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getEmptyChildElementHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}
func (client *XMLClient) GetEmptyList(ctx context.Context, options *XMLGetEmptyListOptions) (XMLGetEmptyListResponse, error) {
	req, err := client.getEmptyListCreateRequest(ctx, options)
	if err != nil {
		return XMLGetEmptyListResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetEmptyListResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetEmptyListResponse{}, client.getEmptyListHandleError(resp)
	}
	return client.getEmptyListHandleResponse(resp)
}
func (client *XMLClient) getEmptyListCreateRequest(ctx context.Context, options *XMLGetEmptyListOptions) (*policy.Request, error) {
	urlPath := "/xml/empty-list"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getEmptyListHandleResponse(resp *http.Response) (XMLGetEmptyListResponse, error) {
	result := XMLGetEmptyListResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.Slideshow); err != nil {
		return XMLGetEmptyListResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getEmptyListHandleError(resp *http.Response) error {
	body, err := runtime.Payload(resp)
	if err != nil {
		return runtime.NewResponseError(err, resp)
	}
	if len(body) == 0 {
		return runtime.NewResponseError(errors.New(resp.Status), resp)
	}
	return runtime.NewResponseError(errors.New(string(body)), resp)
}