queries.go

package urlgroup

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"context"
	"github.com/Azure/go-autorest/autorest"
	"github.com/Azure/go-autorest/autorest/azure"
	"github.com/Azure/go-autorest/autorest/date"
	"github.com/Azure/go-autorest/tracing"
	"net/http"
)

// QueriesClient is the test Infrastructure for AutoRest
type QueriesClient struct {
	BaseClient
}

// NewQueriesClient creates an instance of the QueriesClient client.
func NewQueriesClient(globalStringPath string, globalStringQuery string) QueriesClient {
	return NewQueriesClientWithBaseURI(DefaultBaseURI, globalStringPath, globalStringQuery)
}

// NewQueriesClientWithBaseURI creates an instance of the QueriesClient client using a custom endpoint.  Use this when
// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
func NewQueriesClientWithBaseURI(baseURI string, globalStringPath string, globalStringQuery string) QueriesClient {
	return QueriesClient{NewWithBaseURI(baseURI, globalStringPath, globalStringQuery)}
}

// ArrayStringCsvEmpty get an empty array [] of string using the csv-array format
// Parameters:
// arrayQuery - an empty array [] of string using the csv-array format
func (client QueriesClient) ArrayStringCsvEmpty(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringCsvEmpty")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ArrayStringCsvEmptyPreparer(ctx, arrayQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvEmpty", nil, "Failure preparing request")
		return
	}

	resp, err := client.ArrayStringCsvEmptySender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvEmpty", resp, "Failure sending request")
		return
	}

	result, err = client.ArrayStringCsvEmptyResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvEmpty", resp, "Failure responding to request")
		return
	}

	return
}

// ArrayStringCsvEmptyPreparer prepares the ArrayStringCsvEmpty request.
func (client QueriesClient) ArrayStringCsvEmptyPreparer(ctx context.Context, arrayQuery []string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if arrayQuery != nil && len(arrayQuery) > 0 {
		queryParameters["arrayQuery"] = autorest.Encode("query", arrayQuery, ",")
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/array/csv/string/empty"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ArrayStringCsvEmptySender sends the ArrayStringCsvEmpty request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ArrayStringCsvEmptySender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ArrayStringCsvEmptyResponder handles the response to the ArrayStringCsvEmpty request. The method always
// closes the http.Response Body.
func (client QueriesClient) ArrayStringCsvEmptyResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ArrayStringCsvNull get a null array of string using the csv-array format
// Parameters:
// arrayQuery - a null array of string using the csv-array format
func (client QueriesClient) ArrayStringCsvNull(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringCsvNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ArrayStringCsvNullPreparer(ctx, arrayQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.ArrayStringCsvNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvNull", resp, "Failure sending request")
		return
	}

	result, err = client.ArrayStringCsvNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvNull", resp, "Failure responding to request")
		return
	}

	return
}

// ArrayStringCsvNullPreparer prepares the ArrayStringCsvNull request.
func (client QueriesClient) ArrayStringCsvNullPreparer(ctx context.Context, arrayQuery []string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if arrayQuery != nil && len(arrayQuery) > 0 {
		queryParameters["arrayQuery"] = autorest.Encode("query", arrayQuery, ",")
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/array/csv/string/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ArrayStringCsvNullSender sends the ArrayStringCsvNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ArrayStringCsvNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ArrayStringCsvNullResponder handles the response to the ArrayStringCsvNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) ArrayStringCsvNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ArrayStringCsvValid get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// csv-array format
// Parameters:
// arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// csv-array format
func (client QueriesClient) ArrayStringCsvValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringCsvValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ArrayStringCsvValidPreparer(ctx, arrayQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.ArrayStringCsvValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvValid", resp, "Failure sending request")
		return
	}

	result, err = client.ArrayStringCsvValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringCsvValid", resp, "Failure responding to request")
		return
	}

	return
}

// ArrayStringCsvValidPreparer prepares the ArrayStringCsvValid request.
func (client QueriesClient) ArrayStringCsvValidPreparer(ctx context.Context, arrayQuery []string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if arrayQuery != nil && len(arrayQuery) > 0 {
		queryParameters["arrayQuery"] = autorest.Encode("query", arrayQuery, ",")
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/array/csv/string/valid"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ArrayStringCsvValidSender sends the ArrayStringCsvValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ArrayStringCsvValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ArrayStringCsvValidResponder handles the response to the ArrayStringCsvValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) ArrayStringCsvValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ArrayStringPipesValid get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// pipes-array format
// Parameters:
// arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// pipes-array format
func (client QueriesClient) ArrayStringPipesValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringPipesValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ArrayStringPipesValidPreparer(ctx, arrayQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringPipesValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.ArrayStringPipesValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringPipesValid", resp, "Failure sending request")
		return
	}

	result, err = client.ArrayStringPipesValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringPipesValid", resp, "Failure responding to request")
		return
	}

	return
}

// ArrayStringPipesValidPreparer prepares the ArrayStringPipesValid request.
func (client QueriesClient) ArrayStringPipesValidPreparer(ctx context.Context, arrayQuery []string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if arrayQuery != nil && len(arrayQuery) > 0 {
		queryParameters["arrayQuery"] = autorest.Encode("query", arrayQuery, "|")
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/array/pipes/string/valid"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ArrayStringPipesValidSender sends the ArrayStringPipesValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ArrayStringPipesValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ArrayStringPipesValidResponder handles the response to the ArrayStringPipesValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) ArrayStringPipesValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ArrayStringSsvValid get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// ssv-array format
// Parameters:
// arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// ssv-array format
func (client QueriesClient) ArrayStringSsvValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringSsvValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ArrayStringSsvValidPreparer(ctx, arrayQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringSsvValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.ArrayStringSsvValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringSsvValid", resp, "Failure sending request")
		return
	}

	result, err = client.ArrayStringSsvValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringSsvValid", resp, "Failure responding to request")
		return
	}

	return
}

// ArrayStringSsvValidPreparer prepares the ArrayStringSsvValid request.
func (client QueriesClient) ArrayStringSsvValidPreparer(ctx context.Context, arrayQuery []string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if arrayQuery != nil && len(arrayQuery) > 0 {
		queryParameters["arrayQuery"] = autorest.Encode("query", arrayQuery, " ")
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/array/ssv/string/valid"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ArrayStringSsvValidSender sends the ArrayStringSsvValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ArrayStringSsvValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ArrayStringSsvValidResponder handles the response to the ArrayStringSsvValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) ArrayStringSsvValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ArrayStringTsvValid get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// tsv-array format
// Parameters:
// arrayQuery - an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
// tsv-array format
func (client QueriesClient) ArrayStringTsvValid(ctx context.Context, arrayQuery []string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ArrayStringTsvValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ArrayStringTsvValidPreparer(ctx, arrayQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringTsvValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.ArrayStringTsvValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringTsvValid", resp, "Failure sending request")
		return
	}

	result, err = client.ArrayStringTsvValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ArrayStringTsvValid", resp, "Failure responding to request")
		return
	}

	return
}

// ArrayStringTsvValidPreparer prepares the ArrayStringTsvValid request.
func (client QueriesClient) ArrayStringTsvValidPreparer(ctx context.Context, arrayQuery []string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if arrayQuery != nil && len(arrayQuery) > 0 {
		queryParameters["arrayQuery"] = autorest.Encode("query", arrayQuery, "	")
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/array/tsv/string/valid"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ArrayStringTsvValidSender sends the ArrayStringTsvValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ArrayStringTsvValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ArrayStringTsvValidResponder handles the response to the ArrayStringTsvValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) ArrayStringTsvValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ByteEmpty get '' as byte array
func (client QueriesClient) ByteEmpty(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ByteEmpty")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ByteEmptyPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteEmpty", nil, "Failure preparing request")
		return
	}

	resp, err := client.ByteEmptySender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteEmpty", resp, "Failure sending request")
		return
	}

	result, err = client.ByteEmptyResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteEmpty", resp, "Failure responding to request")
		return
	}

	return
}

// ByteEmptyPreparer prepares the ByteEmpty request.
func (client QueriesClient) ByteEmptyPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"byteQuery": autorest.Encode("query", []byte("")),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/byte/empty"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ByteEmptySender sends the ByteEmpty request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ByteEmptySender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ByteEmptyResponder handles the response to the ByteEmpty request. The method always
// closes the http.Response Body.
func (client QueriesClient) ByteEmptyResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ByteMultiByte get '啊齄丂狛狜隣郎隣兀﨩' multibyte value as utf-8 encoded byte array
// Parameters:
// byteQuery - '啊齄丂狛狜隣郎隣兀﨩' multibyte value as utf-8 encoded byte array
func (client QueriesClient) ByteMultiByte(ctx context.Context, byteQuery []byte) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ByteMultiByte")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ByteMultiBytePreparer(ctx, byteQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteMultiByte", nil, "Failure preparing request")
		return
	}

	resp, err := client.ByteMultiByteSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteMultiByte", resp, "Failure sending request")
		return
	}

	result, err = client.ByteMultiByteResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteMultiByte", resp, "Failure responding to request")
		return
	}

	return
}

// ByteMultiBytePreparer prepares the ByteMultiByte request.
func (client QueriesClient) ByteMultiBytePreparer(ctx context.Context, byteQuery []byte) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if byteQuery != nil && len(byteQuery) > 0 {
		queryParameters["byteQuery"] = autorest.Encode("query", byteQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/byte/multibyte"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ByteMultiByteSender sends the ByteMultiByte request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ByteMultiByteSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ByteMultiByteResponder handles the response to the ByteMultiByte request. The method always
// closes the http.Response Body.
func (client QueriesClient) ByteMultiByteResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// ByteNull get null as byte array (no query parameters in uri)
// Parameters:
// byteQuery - null as byte array (no query parameters in uri)
func (client QueriesClient) ByteNull(ctx context.Context, byteQuery []byte) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.ByteNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.ByteNullPreparer(ctx, byteQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.ByteNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteNull", resp, "Failure sending request")
		return
	}

	result, err = client.ByteNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "ByteNull", resp, "Failure responding to request")
		return
	}

	return
}

// ByteNullPreparer prepares the ByteNull request.
func (client QueriesClient) ByteNullPreparer(ctx context.Context, byteQuery []byte) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if byteQuery != nil && len(byteQuery) > 0 {
		queryParameters["byteQuery"] = autorest.Encode("query", byteQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/byte/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// ByteNullSender sends the ByteNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) ByteNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// ByteNullResponder handles the response to the ByteNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) ByteNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DateNull get null as date - this should result in no query parameters in uri
// Parameters:
// dateQuery - null as date (no query parameters in uri)
func (client QueriesClient) DateNull(ctx context.Context, dateQuery *date.Date) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DateNullPreparer(ctx, dateQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.DateNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateNull", resp, "Failure sending request")
		return
	}

	result, err = client.DateNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateNull", resp, "Failure responding to request")
		return
	}

	return
}

// DateNullPreparer prepares the DateNull request.
func (client QueriesClient) DateNullPreparer(ctx context.Context, dateQuery *date.Date) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if dateQuery != nil {
		queryParameters["dateQuery"] = autorest.Encode("query", *dateQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/date/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DateNullSender sends the DateNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DateNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DateNullResponder handles the response to the DateNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) DateNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DateTimeNull get null as date-time, should result in no query parameters in uri
// Parameters:
// dateTimeQuery - null as date-time (no query parameters)
func (client QueriesClient) DateTimeNull(ctx context.Context, dateTimeQuery *date.Time) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateTimeNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DateTimeNullPreparer(ctx, dateTimeQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.DateTimeNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeNull", resp, "Failure sending request")
		return
	}

	result, err = client.DateTimeNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeNull", resp, "Failure responding to request")
		return
	}

	return
}

// DateTimeNullPreparer prepares the DateTimeNull request.
func (client QueriesClient) DateTimeNullPreparer(ctx context.Context, dateTimeQuery *date.Time) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if dateTimeQuery != nil {
		queryParameters["dateTimeQuery"] = autorest.Encode("query", *dateTimeQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/datetime/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DateTimeNullSender sends the DateTimeNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DateTimeNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DateTimeNullResponder handles the response to the DateTimeNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) DateTimeNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DateTimeValid get '2012-01-01T01:01:01Z' as date-time
func (client QueriesClient) DateTimeValid(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateTimeValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DateTimeValidPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.DateTimeValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeValid", resp, "Failure sending request")
		return
	}

	result, err = client.DateTimeValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateTimeValid", resp, "Failure responding to request")
		return
	}

	return
}

// DateTimeValidPreparer prepares the DateTimeValid request.
func (client QueriesClient) DateTimeValidPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"dateTimeQuery": autorest.Encode("query", "2012-01-01T01:01:01Z"),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/datetime/2012-01-01T01%3A01%3A01Z"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DateTimeValidSender sends the DateTimeValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DateTimeValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DateTimeValidResponder handles the response to the DateTimeValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) DateTimeValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DateValid get '2012-01-01' as date
func (client QueriesClient) DateValid(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DateValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DateValidPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.DateValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateValid", resp, "Failure sending request")
		return
	}

	result, err = client.DateValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DateValid", resp, "Failure responding to request")
		return
	}

	return
}

// DateValidPreparer prepares the DateValid request.
func (client QueriesClient) DateValidPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"dateQuery": autorest.Encode("query", "2012-01-01"),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/date/2012-01-01"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DateValidSender sends the DateValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DateValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DateValidResponder handles the response to the DateValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) DateValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DoubleDecimalNegative get '-9999999.999' numeric value
func (client QueriesClient) DoubleDecimalNegative(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DoubleDecimalNegative")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DoubleDecimalNegativePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalNegative", nil, "Failure preparing request")
		return
	}

	resp, err := client.DoubleDecimalNegativeSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalNegative", resp, "Failure sending request")
		return
	}

	result, err = client.DoubleDecimalNegativeResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalNegative", resp, "Failure responding to request")
		return
	}

	return
}

// DoubleDecimalNegativePreparer prepares the DoubleDecimalNegative request.
func (client QueriesClient) DoubleDecimalNegativePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"doubleQuery": autorest.Encode("query", -9999999.999),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/double/-9999999.999"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DoubleDecimalNegativeSender sends the DoubleDecimalNegative request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DoubleDecimalNegativeSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DoubleDecimalNegativeResponder handles the response to the DoubleDecimalNegative request. The method always
// closes the http.Response Body.
func (client QueriesClient) DoubleDecimalNegativeResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DoubleDecimalPositive get '9999999.999' numeric value
func (client QueriesClient) DoubleDecimalPositive(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DoubleDecimalPositive")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DoubleDecimalPositivePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalPositive", nil, "Failure preparing request")
		return
	}

	resp, err := client.DoubleDecimalPositiveSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalPositive", resp, "Failure sending request")
		return
	}

	result, err = client.DoubleDecimalPositiveResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleDecimalPositive", resp, "Failure responding to request")
		return
	}

	return
}

// DoubleDecimalPositivePreparer prepares the DoubleDecimalPositive request.
func (client QueriesClient) DoubleDecimalPositivePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"doubleQuery": autorest.Encode("query", 9999999.999),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/double/9999999.999"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DoubleDecimalPositiveSender sends the DoubleDecimalPositive request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DoubleDecimalPositiveSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DoubleDecimalPositiveResponder handles the response to the DoubleDecimalPositive request. The method always
// closes the http.Response Body.
func (client QueriesClient) DoubleDecimalPositiveResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// DoubleNull get null numeric value (no query parameter)
// Parameters:
// doubleQuery - null numeric value
func (client QueriesClient) DoubleNull(ctx context.Context, doubleQuery *float64) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.DoubleNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.DoubleNullPreparer(ctx, doubleQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.DoubleNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleNull", resp, "Failure sending request")
		return
	}

	result, err = client.DoubleNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "DoubleNull", resp, "Failure responding to request")
		return
	}

	return
}

// DoubleNullPreparer prepares the DoubleNull request.
func (client QueriesClient) DoubleNullPreparer(ctx context.Context, doubleQuery *float64) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if doubleQuery != nil {
		queryParameters["doubleQuery"] = autorest.Encode("query", *doubleQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/double/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// DoubleNullSender sends the DoubleNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) DoubleNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// DoubleNullResponder handles the response to the DoubleNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) DoubleNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// EnumNull get null (no query parameter in url)
// Parameters:
// enumQuery - null string value
func (client QueriesClient) EnumNull(ctx context.Context, enumQuery URIColor) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.EnumNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.EnumNullPreparer(ctx, enumQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.EnumNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumNull", resp, "Failure sending request")
		return
	}

	result, err = client.EnumNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumNull", resp, "Failure responding to request")
		return
	}

	return
}

// EnumNullPreparer prepares the EnumNull request.
func (client QueriesClient) EnumNullPreparer(ctx context.Context, enumQuery URIColor) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if len(string(enumQuery)) > 0 {
		queryParameters["enumQuery"] = autorest.Encode("query", enumQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/enum/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// EnumNullSender sends the EnumNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) EnumNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// EnumNullResponder handles the response to the EnumNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) EnumNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// EnumValid get using uri with query parameter 'green color'
// Parameters:
// enumQuery - 'green color' enum value
func (client QueriesClient) EnumValid(ctx context.Context, enumQuery URIColor) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.EnumValid")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.EnumValidPreparer(ctx, enumQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumValid", nil, "Failure preparing request")
		return
	}

	resp, err := client.EnumValidSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumValid", resp, "Failure sending request")
		return
	}

	result, err = client.EnumValidResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "EnumValid", resp, "Failure responding to request")
		return
	}

	return
}

// EnumValidPreparer prepares the EnumValid request.
func (client QueriesClient) EnumValidPreparer(ctx context.Context, enumQuery URIColor) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if len(string(enumQuery)) > 0 {
		queryParameters["enumQuery"] = autorest.Encode("query", enumQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/enum/green%20color"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// EnumValidSender sends the EnumValid request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) EnumValidSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// EnumValidResponder handles the response to the EnumValid request. The method always
// closes the http.Response Body.
func (client QueriesClient) EnumValidResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// FloatNull get null numeric value (no query parameter)
// Parameters:
// floatQuery - null numeric value
func (client QueriesClient) FloatNull(ctx context.Context, floatQuery *float64) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.FloatNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.FloatNullPreparer(ctx, floatQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.FloatNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatNull", resp, "Failure sending request")
		return
	}

	result, err = client.FloatNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatNull", resp, "Failure responding to request")
		return
	}

	return
}

// FloatNullPreparer prepares the FloatNull request.
func (client QueriesClient) FloatNullPreparer(ctx context.Context, floatQuery *float64) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if floatQuery != nil {
		queryParameters["floatQuery"] = autorest.Encode("query", *floatQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/float/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// FloatNullSender sends the FloatNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) FloatNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// FloatNullResponder handles the response to the FloatNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) FloatNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// FloatScientificNegative get '-1.034E-20' numeric value
func (client QueriesClient) FloatScientificNegative(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.FloatScientificNegative")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.FloatScientificNegativePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificNegative", nil, "Failure preparing request")
		return
	}

	resp, err := client.FloatScientificNegativeSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificNegative", resp, "Failure sending request")
		return
	}

	result, err = client.FloatScientificNegativeResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificNegative", resp, "Failure responding to request")
		return
	}

	return
}

// FloatScientificNegativePreparer prepares the FloatScientificNegative request.
func (client QueriesClient) FloatScientificNegativePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"floatQuery": autorest.Encode("query", -1.034e-20),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/float/-1.034E-20"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// FloatScientificNegativeSender sends the FloatScientificNegative request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) FloatScientificNegativeSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// FloatScientificNegativeResponder handles the response to the FloatScientificNegative request. The method always
// closes the http.Response Body.
func (client QueriesClient) FloatScientificNegativeResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// FloatScientificPositive get '1.034E+20' numeric value
func (client QueriesClient) FloatScientificPositive(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.FloatScientificPositive")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.FloatScientificPositivePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificPositive", nil, "Failure preparing request")
		return
	}

	resp, err := client.FloatScientificPositiveSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificPositive", resp, "Failure sending request")
		return
	}

	result, err = client.FloatScientificPositiveResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "FloatScientificPositive", resp, "Failure responding to request")
		return
	}

	return
}

// FloatScientificPositivePreparer prepares the FloatScientificPositive request.
func (client QueriesClient) FloatScientificPositivePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"floatQuery": autorest.Encode("query", 1.034e+20),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/float/1.034E+20"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// FloatScientificPositiveSender sends the FloatScientificPositive request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) FloatScientificPositiveSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// FloatScientificPositiveResponder handles the response to the FloatScientificPositive request. The method always
// closes the http.Response Body.
func (client QueriesClient) FloatScientificPositiveResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetBooleanFalse get false Boolean value on path
func (client QueriesClient) GetBooleanFalse(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetBooleanFalse")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetBooleanFalsePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanFalse", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetBooleanFalseSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanFalse", resp, "Failure sending request")
		return
	}

	result, err = client.GetBooleanFalseResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanFalse", resp, "Failure responding to request")
		return
	}

	return
}

// GetBooleanFalsePreparer prepares the GetBooleanFalse request.
func (client QueriesClient) GetBooleanFalsePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"boolQuery": autorest.Encode("query", false),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/bool/false"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetBooleanFalseSender sends the GetBooleanFalse request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetBooleanFalseSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetBooleanFalseResponder handles the response to the GetBooleanFalse request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetBooleanFalseResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetBooleanNull get null Boolean value on query (query string should be absent)
// Parameters:
// boolQuery - null boolean value
func (client QueriesClient) GetBooleanNull(ctx context.Context, boolQuery *bool) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetBooleanNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetBooleanNullPreparer(ctx, boolQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetBooleanNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanNull", resp, "Failure sending request")
		return
	}

	result, err = client.GetBooleanNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanNull", resp, "Failure responding to request")
		return
	}

	return
}

// GetBooleanNullPreparer prepares the GetBooleanNull request.
func (client QueriesClient) GetBooleanNullPreparer(ctx context.Context, boolQuery *bool) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if boolQuery != nil {
		queryParameters["boolQuery"] = autorest.Encode("query", *boolQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/bool/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetBooleanNullSender sends the GetBooleanNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetBooleanNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetBooleanNullResponder handles the response to the GetBooleanNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetBooleanNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetBooleanTrue get true Boolean value on path
func (client QueriesClient) GetBooleanTrue(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetBooleanTrue")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetBooleanTruePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanTrue", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetBooleanTrueSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanTrue", resp, "Failure sending request")
		return
	}

	result, err = client.GetBooleanTrueResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetBooleanTrue", resp, "Failure responding to request")
		return
	}

	return
}

// GetBooleanTruePreparer prepares the GetBooleanTrue request.
func (client QueriesClient) GetBooleanTruePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"boolQuery": autorest.Encode("query", true),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/bool/true"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetBooleanTrueSender sends the GetBooleanTrue request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetBooleanTrueSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetBooleanTrueResponder handles the response to the GetBooleanTrue request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetBooleanTrueResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetIntNegativeOneMillion get '-1000000' integer value
func (client QueriesClient) GetIntNegativeOneMillion(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetIntNegativeOneMillion")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetIntNegativeOneMillionPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNegativeOneMillion", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetIntNegativeOneMillionSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNegativeOneMillion", resp, "Failure sending request")
		return
	}

	result, err = client.GetIntNegativeOneMillionResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNegativeOneMillion", resp, "Failure responding to request")
		return
	}

	return
}

// GetIntNegativeOneMillionPreparer prepares the GetIntNegativeOneMillion request.
func (client QueriesClient) GetIntNegativeOneMillionPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"intQuery": autorest.Encode("query", -1000000),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/int/-1000000"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetIntNegativeOneMillionSender sends the GetIntNegativeOneMillion request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetIntNegativeOneMillionSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetIntNegativeOneMillionResponder handles the response to the GetIntNegativeOneMillion request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetIntNegativeOneMillionResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetIntNull get null integer value (no query parameter)
// Parameters:
// intQuery - null integer value
func (client QueriesClient) GetIntNull(ctx context.Context, intQuery *int32) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetIntNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetIntNullPreparer(ctx, intQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetIntNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNull", resp, "Failure sending request")
		return
	}

	result, err = client.GetIntNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntNull", resp, "Failure responding to request")
		return
	}

	return
}

// GetIntNullPreparer prepares the GetIntNull request.
func (client QueriesClient) GetIntNullPreparer(ctx context.Context, intQuery *int32) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if intQuery != nil {
		queryParameters["intQuery"] = autorest.Encode("query", *intQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/int/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetIntNullSender sends the GetIntNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetIntNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetIntNullResponder handles the response to the GetIntNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetIntNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetIntOneMillion get '1000000' integer value
func (client QueriesClient) GetIntOneMillion(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetIntOneMillion")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetIntOneMillionPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntOneMillion", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetIntOneMillionSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntOneMillion", resp, "Failure sending request")
		return
	}

	result, err = client.GetIntOneMillionResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetIntOneMillion", resp, "Failure responding to request")
		return
	}

	return
}

// GetIntOneMillionPreparer prepares the GetIntOneMillion request.
func (client QueriesClient) GetIntOneMillionPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"intQuery": autorest.Encode("query", 1000000),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/int/1000000"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetIntOneMillionSender sends the GetIntOneMillion request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetIntOneMillionSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetIntOneMillionResponder handles the response to the GetIntOneMillion request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetIntOneMillionResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetLongNull get 'null 64 bit integer value (no query param in uri)
// Parameters:
// longQuery - null 64 bit integer value
func (client QueriesClient) GetLongNull(ctx context.Context, longQuery *int64) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetLongNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetLongNullPreparer(ctx, longQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetLongNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetLongNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetLongNull", resp, "Failure sending request")
		return
	}

	result, err = client.GetLongNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetLongNull", resp, "Failure responding to request")
		return
	}

	return
}

// GetLongNullPreparer prepares the GetLongNull request.
func (client QueriesClient) GetLongNullPreparer(ctx context.Context, longQuery *int64) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if longQuery != nil {
		queryParameters["longQuery"] = autorest.Encode("query", *longQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/long/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetLongNullSender sends the GetLongNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetLongNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetLongNullResponder handles the response to the GetLongNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetLongNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetNegativeTenBillion get '-10000000000' 64 bit integer value
func (client QueriesClient) GetNegativeTenBillion(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetNegativeTenBillion")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetNegativeTenBillionPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetNegativeTenBillion", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetNegativeTenBillionSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetNegativeTenBillion", resp, "Failure sending request")
		return
	}

	result, err = client.GetNegativeTenBillionResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetNegativeTenBillion", resp, "Failure responding to request")
		return
	}

	return
}

// GetNegativeTenBillionPreparer prepares the GetNegativeTenBillion request.
func (client QueriesClient) GetNegativeTenBillionPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"longQuery": autorest.Encode("query", -10000000000),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/long/-10000000000"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetNegativeTenBillionSender sends the GetNegativeTenBillion request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetNegativeTenBillionSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetNegativeTenBillionResponder handles the response to the GetNegativeTenBillion request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetNegativeTenBillionResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// GetTenBillion get '10000000000' 64 bit integer value
func (client QueriesClient) GetTenBillion(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.GetTenBillion")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.GetTenBillionPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetTenBillion", nil, "Failure preparing request")
		return
	}

	resp, err := client.GetTenBillionSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetTenBillion", resp, "Failure sending request")
		return
	}

	result, err = client.GetTenBillionResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "GetTenBillion", resp, "Failure responding to request")
		return
	}

	return
}

// GetTenBillionPreparer prepares the GetTenBillion request.
func (client QueriesClient) GetTenBillionPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"longQuery": autorest.Encode("query", 10000000000),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/long/10000000000"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// GetTenBillionSender sends the GetTenBillion request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) GetTenBillionSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// GetTenBillionResponder handles the response to the GetTenBillion request. The method always
// closes the http.Response Body.
func (client QueriesClient) GetTenBillionResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// StringEmpty get ''
func (client QueriesClient) StringEmpty(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringEmpty")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.StringEmptyPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringEmpty", nil, "Failure preparing request")
		return
	}

	resp, err := client.StringEmptySender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringEmpty", resp, "Failure sending request")
		return
	}

	result, err = client.StringEmptyResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringEmpty", resp, "Failure responding to request")
		return
	}

	return
}

// StringEmptyPreparer prepares the StringEmpty request.
func (client QueriesClient) StringEmptyPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"stringQuery": autorest.Encode("query", ""),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/string/empty"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// StringEmptySender sends the StringEmpty request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) StringEmptySender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// StringEmptyResponder handles the response to the StringEmpty request. The method always
// closes the http.Response Body.
func (client QueriesClient) StringEmptyResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// StringNull get null (no query parameter in url)
// Parameters:
// stringQuery - null string value
func (client QueriesClient) StringNull(ctx context.Context, stringQuery string) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringNull")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.StringNullPreparer(ctx, stringQuery)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringNull", nil, "Failure preparing request")
		return
	}

	resp, err := client.StringNullSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringNull", resp, "Failure sending request")
		return
	}

	result, err = client.StringNullResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringNull", resp, "Failure responding to request")
		return
	}

	return
}

// StringNullPreparer prepares the StringNull request.
func (client QueriesClient) StringNullPreparer(ctx context.Context, stringQuery string) (*http.Request, error) {
	queryParameters := map[string]interface{}{}
	if len(stringQuery) > 0 {
		queryParameters["stringQuery"] = autorest.Encode("query", stringQuery)
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/string/null"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// StringNullSender sends the StringNull request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) StringNullSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// StringNullResponder handles the response to the StringNull request. The method always
// closes the http.Response Body.
func (client QueriesClient) StringNullResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// StringUnicode get '啊齄丂狛狜隣郎隣兀﨩' multi-byte string value
func (client QueriesClient) StringUnicode(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringUnicode")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.StringUnicodePreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringUnicode", nil, "Failure preparing request")
		return
	}

	resp, err := client.StringUnicodeSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringUnicode", resp, "Failure sending request")
		return
	}

	result, err = client.StringUnicodeResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringUnicode", resp, "Failure responding to request")
		return
	}

	return
}

// StringUnicodePreparer prepares the StringUnicode request.
func (client QueriesClient) StringUnicodePreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"stringQuery": autorest.Encode("query", "啊齄丂狛狜隣郎隣兀﨩"),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/string/unicode/"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// StringUnicodeSender sends the StringUnicode request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) StringUnicodeSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// StringUnicodeResponder handles the response to the StringUnicode request. The method always
// closes the http.Response Body.
func (client QueriesClient) StringUnicodeResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}

// StringURLEncoded get 'begin!*'();:@ &=+$,/?#[]end
func (client QueriesClient) StringURLEncoded(ctx context.Context) (result autorest.Response, err error) {
	if tracing.IsEnabled() {
		ctx = tracing.StartSpan(ctx, fqdn+"/QueriesClient.StringURLEncoded")
		defer func() {
			sc := -1
			if result.Response != nil {
				sc = result.Response.StatusCode
			}
			tracing.EndSpan(ctx, sc, err)
		}()
	}
	req, err := client.StringURLEncodedPreparer(ctx)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringURLEncoded", nil, "Failure preparing request")
		return
	}

	resp, err := client.StringURLEncodedSender(req)
	if err != nil {
		result.Response = resp
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringURLEncoded", resp, "Failure sending request")
		return
	}

	result, err = client.StringURLEncodedResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "urlgroup.QueriesClient", "StringURLEncoded", resp, "Failure responding to request")
		return
	}

	return
}

// StringURLEncodedPreparer prepares the StringURLEncoded request.
func (client QueriesClient) StringURLEncodedPreparer(ctx context.Context) (*http.Request, error) {
	queryParameters := map[string]interface{}{
		"stringQuery": autorest.Encode("query", "begin!*'();:@ &=+$,/?#[]end"),
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPath("/queries/string/begin%21%2A%27%28%29%3B%3A%40%20%26%3D%2B%24%2C%2F%3F%23%5B%5Dend"),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare((&http.Request{}).WithContext(ctx))
}

// StringURLEncodedSender sends the StringURLEncoded request. The method will close the
// http.Response Body if it receives an error.
func (client QueriesClient) StringURLEncodedSender(req *http.Request) (*http.Response, error) {
	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}

// StringURLEncodedResponder handles the response to the StringURLEncoded request. The method always
// closes the http.Response Body.
func (client QueriesClient) StringURLEncodedResponder(resp *http.Response) (result autorest.Response, err error) {
	err = autorest.Respond(
		resp,
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByClosing())
	result.Response = resp
	return
}