func (client *XMLClient) getXMsTextHandleError(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)
}
getXMsTextHandleError handles the GetXMsText error response.
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)
}
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)
}
func (client *XMLClient) getEmptyRootListCreateRequest(ctx context.Context, options *XMLGetEmptyRootListOptions) (*policy.Request, error) {
	urlPath := "/xml/empty-root-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) getEmptyRootListHandleResponse(resp *http.Response) (XMLGetEmptyRootListResponse, error) {
	result := XMLGetEmptyRootListResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result); err != nil {
		return XMLGetEmptyRootListResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getEmptyRootListHandleError(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) GetEmptyWrappedLists(ctx context.Context, options *XMLGetEmptyWrappedListsOptions) (XMLGetEmptyWrappedListsResponse, error) {
	req, err := client.getEmptyWrappedListsCreateRequest(ctx, options)
	if err != nil {
		return XMLGetEmptyWrappedListsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetEmptyWrappedListsResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetEmptyWrappedListsResponse{}, client.getEmptyWrappedListsHandleError(resp)
	}
	return client.getEmptyWrappedListsHandleResponse(resp)
}
func (client *XMLClient) getEmptyWrappedListsCreateRequest(ctx context.Context, options *XMLGetEmptyWrappedListsOptions) (*policy.Request, error) {
	urlPath := "/xml/empty-wrapped-lists"
	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) getEmptyWrappedListsHandleResponse(resp *http.Response) (XMLGetEmptyWrappedListsResponse, error) {
	result := XMLGetEmptyWrappedListsResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.AppleBarrel); err != nil {
		return XMLGetEmptyWrappedListsResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getEmptyWrappedListsHandleError(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) GetHeaders(ctx context.Context, options *XMLGetHeadersOptions) (XMLGetHeadersResponse, error) {
	req, err := client.getHeadersCreateRequest(ctx, options)
	if err != nil {
		return XMLGetHeadersResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetHeadersResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetHeadersResponse{}, client.getHeadersHandleError(resp)
	}
	return client.getHeadersHandleResponse(resp)
}
func (client *XMLClient) getHeadersCreateRequest(ctx context.Context, options *XMLGetHeadersOptions) (*policy.Request, error) {
	urlPath := "/xml/headers"
	req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.con.Endpoint(), urlPath))
	if err != nil {
		return nil, err
	}
	return req, nil
}
func (client *XMLClient) getHeadersHandleResponse(resp *http.Response) (XMLGetHeadersResponse, error) {
	result := XMLGetHeadersResponse{RawResponse: resp}
	if val := resp.Header.Get("Custom-Header"); val != "" {
		result.CustomHeader = &val
	}
	return result, nil
}
func (client *XMLClient) getHeadersHandleError(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) GetRootList(ctx context.Context, options *XMLGetRootListOptions) (XMLGetRootListResponse, error) {
	req, err := client.getRootListCreateRequest(ctx, options)
	if err != nil {
		return XMLGetRootListResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetRootListResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetRootListResponse{}, client.getRootListHandleError(resp)
	}
	return client.getRootListHandleResponse(resp)
}
func (client *XMLClient) getRootListCreateRequest(ctx context.Context, options *XMLGetRootListOptions) (*policy.Request, error) {
	urlPath := "/xml/root-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) getRootListHandleResponse(resp *http.Response) (XMLGetRootListResponse, error) {
	result := XMLGetRootListResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result); err != nil {
		return XMLGetRootListResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getRootListHandleError(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) GetRootListSingleItem(ctx context.Context, options *XMLGetRootListSingleItemOptions) (XMLGetRootListSingleItemResponse, error) {
	req, err := client.getRootListSingleItemCreateRequest(ctx, options)
	if err != nil {
		return XMLGetRootListSingleItemResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetRootListSingleItemResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetRootListSingleItemResponse{}, client.getRootListSingleItemHandleError(resp)
	}
	return client.getRootListSingleItemHandleResponse(resp)
}
func (client *XMLClient) getRootListSingleItemCreateRequest(ctx context.Context, options *XMLGetRootListSingleItemOptions) (*policy.Request, error) {
	urlPath := "/xml/root-list-single-item"
	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) getRootListSingleItemHandleResponse(resp *http.Response) (XMLGetRootListSingleItemResponse, error) {
	result := XMLGetRootListSingleItemResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result); err != nil {
		return XMLGetRootListSingleItemResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getRootListSingleItemHandleError(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) GetServiceProperties(ctx context.Context, options *XMLGetServicePropertiesOptions) (XMLGetServicePropertiesResponse, error) {
	req, err := client.getServicePropertiesCreateRequest(ctx, options)
	if err != nil {
		return XMLGetServicePropertiesResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetServicePropertiesResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetServicePropertiesResponse{}, client.getServicePropertiesHandleError(resp)
	}
	return client.getServicePropertiesHandleResponse(resp)
}
func (client *XMLClient) getServicePropertiesCreateRequest(ctx context.Context, options *XMLGetServicePropertiesOptions) (*policy.Request, error) {
	urlPath := "/xml/"
	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", "properties")
	reqQP.Set("restype", "service")
	req.Raw().URL.RawQuery = reqQP.Encode()
	req.Raw().Header.Set("Accept", "application/xml")
	return req, nil
}
func (client *XMLClient) getServicePropertiesHandleResponse(resp *http.Response) (XMLGetServicePropertiesResponse, error) {
	result := XMLGetServicePropertiesResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.StorageServiceProperties); err != nil {
		return XMLGetServicePropertiesResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getServicePropertiesHandleError(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) GetSimple(ctx context.Context, options *XMLGetSimpleOptions) (XMLGetSimpleResponse, error) {
	req, err := client.getSimpleCreateRequest(ctx, options)
	if err != nil {
		return XMLGetSimpleResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetSimpleResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetSimpleResponse{}, client.getSimpleHandleError(resp)
	}
	return client.getSimpleHandleResponse(resp)
}
func (client *XMLClient) getSimpleCreateRequest(ctx context.Context, options *XMLGetSimpleOptions) (*policy.Request, error) {
	urlPath := "/xml/simple"
	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) getSimpleHandleResponse(resp *http.Response) (XMLGetSimpleResponse, error) {
	result := XMLGetSimpleResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.Slideshow); err != nil {
		return XMLGetSimpleResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getSimpleHandleError(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) GetURI(ctx context.Context, options *XMLGetURIOptions) (XMLGetURIResponse, error) {
	req, err := client.getURICreateRequest(ctx, options)
	if err != nil {
		return XMLGetURIResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetURIResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetURIResponse{}, client.getURIHandleError(resp)
	}
	return client.getURIHandleResponse(resp)
}
func (client *XMLClient) getURICreateRequest(ctx context.Context, options *XMLGetURIOptions) (*policy.Request, error) {
	urlPath := "/xml/url"
	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) getURIHandleResponse(resp *http.Response) (XMLGetURIResponse, error) {
	result := XMLGetURIResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.ModelWithURLProperty); err != nil {
		return XMLGetURIResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getURIHandleError(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) GetWrappedLists(ctx context.Context, options *XMLGetWrappedListsOptions) (XMLGetWrappedListsResponse, error) {
	req, err := client.getWrappedListsCreateRequest(ctx, options)
	if err != nil {
		return XMLGetWrappedListsResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetWrappedListsResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetWrappedListsResponse{}, client.getWrappedListsHandleError(resp)
	}
	return client.getWrappedListsHandleResponse(resp)
}
func (client *XMLClient) getWrappedListsCreateRequest(ctx context.Context, options *XMLGetWrappedListsOptions) (*policy.Request, error) {
	urlPath := "/xml/wrapped-lists"
	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) getWrappedListsHandleResponse(resp *http.Response) (XMLGetWrappedListsResponse, error) {
	result := XMLGetWrappedListsResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.AppleBarrel); err != nil {
		return XMLGetWrappedListsResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}
func (client *XMLClient) getWrappedListsHandleError(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) GetXMsText(ctx context.Context, options *XMLGetXMsTextOptions) (XMLGetXMsTextResponse, error) {
	req, err := client.getXMsTextCreateRequest(ctx, options)
	if err != nil {
		return XMLGetXMsTextResponse{}, err
	}
	resp, err := client.con.Pipeline().Do(req)
	if err != nil {
		return XMLGetXMsTextResponse{}, err
	}
	if !runtime.HasStatusCode(resp, http.StatusOK) {
		return XMLGetXMsTextResponse{}, client.getXMsTextHandleError(resp)
	}
	return client.getXMsTextHandleResponse(resp)
}
func (client *XMLClient) getXMsTextCreateRequest(ctx context.Context, options *XMLGetXMsTextOptions) (*policy.Request, error) {
	urlPath := "/xml/x-ms-text"
	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) getXMsTextHandleResponse(resp *http.Response) (XMLGetXMsTextResponse, error) {
	result := XMLGetXMsTextResponse{RawResponse: resp}
	if err := runtime.UnmarshalAsXML(resp, &result.ObjectWithXMsTextProperty); err != nil {
		return XMLGetXMsTextResponse{}, runtime.NewResponseError(err, resp)
	}
	return result, nil
}