text: # coding=utf-8
  # --------------------------------------------------------------------------
  # 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 datetime
  from typing import TYPE_CHECKING
  
  from azure.core.rest import HttpRequest
  from msrest import Serializer
  
  from ..._vendor import _format_url_section
  
  if TYPE_CHECKING:
      # pylint: disable=unused-import,ungrouped-imports
      from typing import Any, List, Optional
  
  _SERIALIZER = Serializer()
  
  # fmt: off
  
  def build_get_boolean_true_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get true Boolean value on path.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      bool_query = True
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/bool/true')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['boolQuery'] = _SERIALIZER.query("bool_query", bool_query, 'bool')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_boolean_false_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get false Boolean value on path.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      bool_query = False
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/bool/false')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['boolQuery'] = _SERIALIZER.query("bool_query", bool_query, 'bool')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_boolean_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null Boolean value on query (query string should be absent).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword bool_query: null boolean value.
      :paramtype bool_query: bool
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      bool_query = kwargs.pop('bool_query', None)  # type: Optional[bool]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/bool/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if bool_query is not None:
          query_parameters['boolQuery'] = _SERIALIZER.query("bool_query", bool_query, 'bool')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_int_one_million_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '1000000' integer value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      int_query = 1000000
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/int/1000000')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['intQuery'] = _SERIALIZER.query("int_query", int_query, 'int')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_int_negative_one_million_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '-1000000' integer value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      int_query = -1000000
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/int/-1000000')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['intQuery'] = _SERIALIZER.query("int_query", int_query, 'int')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_int_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null integer value (no query parameter).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword int_query: null integer value.
      :paramtype int_query: int
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      int_query = kwargs.pop('int_query', None)  # type: Optional[int]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/int/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if int_query is not None:
          query_parameters['intQuery'] = _SERIALIZER.query("int_query", int_query, 'int')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_ten_billion_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '10000000000' 64 bit integer value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      long_query = 10000000000
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/long/10000000000')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['longQuery'] = _SERIALIZER.query("long_query", long_query, 'long')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_negative_ten_billion_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '-10000000000' 64 bit integer value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      long_query = -10000000000
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/long/-10000000000')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['longQuery'] = _SERIALIZER.query("long_query", long_query, 'long')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_get_long_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get 'null 64 bit integer value (no query param in uri).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword long_query: null 64 bit integer value.
      :paramtype long_query: long
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      long_query = kwargs.pop('long_query', None)  # type: Optional[int]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/long/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if long_query is not None:
          query_parameters['longQuery'] = _SERIALIZER.query("long_query", long_query, 'long')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_float_scientific_positive_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '1.034E+20' numeric value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      float_query = 103400000000000000000
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/float/1.034E+20')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['floatQuery'] = _SERIALIZER.query("float_query", float_query, 'float')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_float_scientific_negative_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '-1.034E-20' numeric value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      float_query = -1.034e-20
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/float/-1.034E-20')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['floatQuery'] = _SERIALIZER.query("float_query", float_query, 'float')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_float_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null numeric value (no query parameter).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword float_query: null numeric value.
      :paramtype float_query: float
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      float_query = kwargs.pop('float_query', None)  # type: Optional[float]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/float/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if float_query is not None:
          query_parameters['floatQuery'] = _SERIALIZER.query("float_query", float_query, 'float')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_double_decimal_positive_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '9999999.999' numeric value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      double_query = 9999999.999
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/double/9999999.999')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['doubleQuery'] = _SERIALIZER.query("double_query", double_query, 'float')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_double_decimal_negative_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '-9999999.999' numeric value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      double_query = -9999999.999
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/double/-9999999.999')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['doubleQuery'] = _SERIALIZER.query("double_query", double_query, 'float')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_double_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null numeric value (no query parameter).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword double_query: null numeric value.
      :paramtype double_query: float
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      double_query = kwargs.pop('double_query', None)  # type: Optional[float]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/double/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if double_query is not None:
          query_parameters['doubleQuery'] = _SERIALIZER.query("double_query", double_query, 'float')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_string_unicode_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '啊齄丂狛狜隣郎隣兀﨩' multi-byte string value.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      string_query = "啊齄丂狛狜隣郎隣兀﨩"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/string/unicode/')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['stringQuery'] = _SERIALIZER.query("string_query", string_query, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_string_url_encoded_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get 'begin!*'();:@ &=+$,/?#[]end.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      string_query = "begin!*'();:@ &=+$,/?#[]end"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/string/begin%21%2A%27%28%29%3B%3A%40%20%26%3D%2B%24%2C%2F%3F%23%5B%5Dend')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['stringQuery'] = _SERIALIZER.query("string_query", string_query, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_string_empty_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get ''.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      string_query = ""
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/string/empty')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['stringQuery'] = _SERIALIZER.query("string_query", string_query, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_string_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null (no query parameter in url).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword string_query: null string value.
      :paramtype string_query: str
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      string_query = kwargs.pop('string_query', None)  # type: Optional[str]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/string/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if string_query is not None:
          query_parameters['stringQuery'] = _SERIALIZER.query("string_query", string_query, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_enum_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get using uri with query parameter 'green color'.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword enum_query: 'green color' enum value. Possible values are: "red color", "green color",
       and "blue color".
      :paramtype enum_query: str
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      enum_query = kwargs.pop('enum_query', None)  # type: Optional[str]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/enum/green%20color')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if enum_query is not None:
          query_parameters['enumQuery'] = _SERIALIZER.query("enum_query", enum_query, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_enum_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null (no query parameter in url).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword enum_query: null string value. Possible values are: "red color", "green color", and
       "blue color".
      :paramtype enum_query: str
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      enum_query = kwargs.pop('enum_query', None)  # type: Optional[str]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/enum/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if enum_query is not None:
          query_parameters['enumQuery'] = _SERIALIZER.query("enum_query", enum_query, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_byte_multi_byte_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '啊齄丂狛狜隣郎隣兀﨩' multibyte value as utf-8 encoded byte array.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword byte_query: '啊齄丂狛狜隣郎隣兀﨩' multibyte value as utf-8 encoded byte array.
      :paramtype byte_query: bytearray
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      byte_query = kwargs.pop('byte_query', None)  # type: Optional[bytearray]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/byte/multibyte')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if byte_query is not None:
          query_parameters['byteQuery'] = _SERIALIZER.query("byte_query", byte_query, 'bytearray')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_byte_empty_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '' as byte array.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      byte_query = bytearray("", encoding="utf-8")
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/byte/empty')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['byteQuery'] = _SERIALIZER.query("byte_query", byte_query, 'bytearray')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_byte_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null as byte array (no query parameters in uri).
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword byte_query: null as byte array (no query parameters in uri).
      :paramtype byte_query: bytearray
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      byte_query = kwargs.pop('byte_query', None)  # type: Optional[bytearray]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/byte/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if byte_query is not None:
          query_parameters['byteQuery'] = _SERIALIZER.query("byte_query", byte_query, 'bytearray')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_date_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '2012-01-01' as date.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      date_query = "2012-01-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/date/2012-01-01')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['dateQuery'] = _SERIALIZER.query("date_query", date_query, 'date')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_date_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null as date - this should result in no query parameters in uri.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword date_query: null as date (no query parameters in uri).
      :paramtype date_query: ~datetime.date
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      date_query = kwargs.pop('date_query', None)  # type: Optional[datetime.date]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/date/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if date_query is not None:
          query_parameters['dateQuery'] = _SERIALIZER.query("date_query", date_query, 'date')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_date_time_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get '2012-01-01T01:01:01Z' as date-time.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      date_time_query = "2012-01-01T01:01:01Z"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/datetime/2012-01-01T01%3A01%3A01Z')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['dateTimeQuery'] = _SERIALIZER.query("date_time_query", date_time_query, 'iso-8601')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_date_time_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get null as date-time, should result in no query parameters in uri.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword date_time_query: null as date-time (no query parameters).
      :paramtype date_time_query: ~datetime.datetime
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      date_time_query = kwargs.pop('date_time_query', None)  # type: Optional[datetime.datetime]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/datetime/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if date_time_query is not None:
          query_parameters['dateTimeQuery'] = _SERIALIZER.query("date_time_query", date_time_query, 'iso-8601')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_csv_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
      csv-array format.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null,
       ''] using the csv-array format.
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/csv/string/valid')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div=',')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_csv_null_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get a null array of string using the csv-array format.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: a null array of string using the csv-array format.
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/csv/string/null')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div=',')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_csv_empty_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get an empty array [] of string using the csv-array format.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: an empty array [] of string using the csv-array format.
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/csv/string/empty')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div=',')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_no_collection_format_empty_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Array query has no defined collection format, should default to csv. Pass in ['hello', 'nihao',
      'bonjour'] for the 'arrayQuery' parameter to the service.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: Array-typed query parameter. Pass in ['hello', 'nihao', 'bonjour'].
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/none/string/empty')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div=',')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_ssv_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
      ssv-array format.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null,
       ''] using the ssv-array format.
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/ssv/string/valid')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div=' ')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_tsv_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
      tsv-array format.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null,
       ''] using the tsv-array format.
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/tsv/string/valid')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div='	')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_array_string_pipes_valid_request(
      **kwargs  # type: Any
  ):
      # type: (...) -> HttpRequest
      """Get an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null, ''] using the
      pipes-array format.
  
      See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this request builder
      into your code flow.
  
      :keyword array_query: an array of string ['ArrayQuery1', 'begin!*'();:@ &=+$,/?#[]end' , null,
       ''] using the pipes-array format.
      :paramtype array_query: list[str]
      :return: Returns an :class:`~azure.core.rest.HttpRequest` that you will pass to the client's
       `send_request` method. See https://aka.ms/azsdk/python/protocol/quickstart for how to
       incorporate this response into your code flow.
      :rtype: ~azure.core.rest.HttpRequest
      """
  
      array_query = kwargs.pop('array_query', None)  # type: Optional[List[str]]
  
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/queries/array/pipes/string/valid')
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if array_query is not None:
          query_parameters['arrayQuery'] = _SERIALIZER.query("array_query", array_query, '[str]', div='|')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  