@autorest/python 5.16.0 → 5.19.0

package/autorest/codegen/serializers/builder_serializer.py

@@ -4,11 +4,10 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from itertools import groupby
 import json
+from abc import abstractmethod
 from collections import defaultdict
-from abc import abstractmethod, ABC
-from typing import Any, List, TypeVar, Dict, Union, Optional, cast
+from typing import Any, Generic, List, Type, TypeVar, Dict, Union, Optional, cast
 
 
 from ..models import (
@@ -17,25 +16,45 @@ from ..models import (
     PagingOperation,
     LROOperation,
     LROPagingOperation,
-    ObjectSchema,
-    DictionarySchema,
-    ListSchema,
-    BaseSchema,
+    ModelType,
+    DictionaryType,
+    ListType,
     Parameter,
     RequestBuilder,
-    RequestBuilderParameter,
-    EnumSchema,
-    SchemaResponse,
-    IOSchema,
-    ParameterStyle,
     ParameterLocation,
+    Response,
+    BinaryType,
+    BodyParameter,
     ParameterMethodLocation,
+    RequestBuilderBodyParameter,
+    OverloadedRequestBuilder,
+    ConstantType,
+    MultipartBodyParameter,
+    Property,
+    RequestBuilderType,
 )
+from .parameter_serializer import ParameterSerializer, PopKwargType
 from . import utils
 
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
+BuilderType = TypeVar(
+    "BuilderType",
+    bound=Union[
+        RequestBuilder,
+        Operation,
+        PagingOperation,
+        LROOperation,
+        LROPagingOperation,
+        OverloadedRequestBuilder,
+    ],
+)
+OperationType = TypeVar(
+    "OperationType",
+    bound=Union[Operation, PagingOperation, LROOperation, LROPagingOperation],
+)
+
 
 def _escape_str(input_str: str) -> str:
     replace = input_str.replace("'", "\\'")
@@ -65,247 +84,176 @@ def _json_dumps_template(template_representation: Any) -> Any:
     )
 
 
-def _content_type_error_check(builder) -> List[str]:
-    retval = ["else:"]
-    retval.append("    raise ValueError(")
+def _get_polymorphic_subtype_template(polymorphic_subtype: ModelType) -> List[str]:
+    retval: List[str] = []
+    retval.append("")
     retval.append(
-        "        \"The content_type '{}' is not one of the allowed values: \""
+        f'# JSON input template for discriminator value "{polymorphic_subtype.discriminator_value}":'
+    )
+    subtype_template = _json_dumps_template(
+        polymorphic_subtype.get_json_template_representation(),
     )
-    retval.append(f'        "{builder.parameters.content_types}".format(content_type)')
-    retval.append("    )")
-    return retval
-
 
-def _serialize_files_and_data_body(builder, param_name: str) -> List[str]:
-    retval: List[str] = []
-    # we have to construct our form data before passing to the request as well
-    retval.append("# Construct form data")
-    retval.append(f"{param_name} = {{")
-    for param in builder.parameters.body:
-        retval.append(f'    "{param.rest_api_name}": {param.serialized_name},')
-    retval.append("}")
+    def _get_polymorphic_parent(
+        polymorphic_subtype: Optional[ModelType],
+    ) -> Optional[ModelType]:
+        if not polymorphic_subtype:
+            return None
+        try:
+            return next(
+                p for p in polymorphic_subtype.parents if p.discriminated_subtypes
+            )
+        except StopIteration:
+            return None
+
+    polymorphic_parent = _get_polymorphic_parent(polymorphic_subtype)
+    while _get_polymorphic_parent(polymorphic_parent):
+        polymorphic_parent = _get_polymorphic_parent(polymorphic_parent)
+    retval.extend(
+        f"{cast(ModelType, polymorphic_parent).snake_case_name} = {subtype_template}".splitlines()
+    )
     return retval
 
 
-def _serialize_grouped_body(builder) -> List[str]:
+def _serialize_grouped_body(builder: BuilderType) -> List[str]:
     retval: List[str] = []
     for grouped_parameter in builder.parameters.grouped:
-        retval.append(f"{grouped_parameter.serialized_name} = None")
-    for grouper_name, grouped_parameters in groupby(
-        builder.parameters.grouped,
-        key=lambda a: cast(Parameter, a.grouped_by).serialized_name,
-    ):
-        retval.append(f"if {grouper_name} is not None:")
-        for grouped_parameter in grouped_parameters:
-            retval.append(
-                f"    {grouped_parameter.serialized_name} = "
-                f"{ grouper_name }.{ grouped_parameter.corresponding_grouped_property.name }"
-            )
+        retval.append(f"{grouped_parameter.client_name} = None")
+    groupers = [p for p in builder.parameters if p.grouper]
+    for grouper in groupers:
+        retval.append(f"if {grouper.client_name} is not None:")
+        retval.extend(
+            [
+                f"    {parameter} = {grouper.client_name}.{property}"
+                for property, parameter in grouper.property_to_parameter_name.items()
+            ]
+        )
     return retval
 
 
-def _serialize_flattened_body(builder) -> List[str]:
+def _serialize_flattened_body(body_parameter: BodyParameter) -> List[str]:
     retval: List[str] = []
-    if not builder.parameters.is_flattened:
+    if not body_parameter.property_to_parameter_name:
         raise ValueError(
             "This method can't be called if the operation doesn't need parameter flattening"
         )
 
-    parameters = builder.parameters.get_from_predicate(
-        lambda parameter: parameter.in_method_code
-    )
     parameter_string = ", ".join(
-        [
-            f"{param.target_property_name}={param.serialized_name}"
-            for param in parameters
-            if param.target_property_name
-        ]
+        f"{property_name}={parameter_name}"
+        for property_name, parameter_name in body_parameter.property_to_parameter_name.items()
     )
-    object_schema = cast(ObjectSchema, builder.parameters.body[0].schema)
+    model_type = cast(ModelType, body_parameter.type)
     retval.append(
-        f"{builder.parameters.body[0].serialized_name} = _models.{object_schema.name}({parameter_string})"
+        f"{body_parameter.client_name} = _models.{model_type.name}({parameter_string})"
     )
     return retval
 
 
-def _content_type_docstring(builder) -> str:
-    content_types = [f'"{c}"' for c in builder.parameters.content_types]
-    if len(content_types) == 2:
-        possible_values_str = " or ".join(content_types)
-    else:
-        possible_values_str = (
-            ", ".join(content_types[: len(content_types) - 1])
-            + f", and {content_types[-1]}"
-        )
-    default_value = next(
-        p for p in builder.parameters.method if p.rest_api_name == "Content-Type"
-    ).default_value_declaration
-    return (
-        ":keyword content_type: Media type of the body sent to the API. "
-        + f"Known values are: {possible_values_str}. "
-        + f"Default value is {default_value}."
-    )
+def _serialize_multipart_body(builder: BuilderType) -> List[str]:
+    retval: List[str] = []
+    body_param = cast(MultipartBodyParameter, builder.parameters.body_parameter)
+    # we have to construct our form data before passing to the request as well
+    retval.append("# Construct form data")
+    retval.append(f"_{body_param.client_name} = {{")
+    for param in body_param.entries:
+        retval.append(f'    "{param.rest_api_name}": {param.client_name},')
+    retval.append("}")
+    return retval
+
+
+def _get_json_response_template_to_status_codes(
+    builder: OperationType,
+) -> Dict[str, List[str]]:
+    retval = defaultdict(list)
+    for response in builder.responses:
+        json_template = response.get_json_template_representation()
+        if not json_template:
+            continue
+        status_codes = [str(status_code) for status_code in response.status_codes]
+        response_json = _json_dumps_template(json_template)
+        retval[response_json].extend(status_codes)
+    return retval
 
 
-class _BuilderSerializerProtocol(ABC):
+class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
+    def __init__(
+        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
+    ) -> None:
+        self.code_model = code_model
+        self.async_mode = async_mode
+        self.is_python3_file = is_python3_file
+        self.parameter_serializer = ParameterSerializer()
+
     @property
     @abstractmethod
-    def _is_in_class(self) -> bool:
+    def _need_self_param(self) -> bool:
         ...
 
     @property
     @abstractmethod
-    def _function_definition(self) -> str:
+    def _function_def(self) -> str:
         """The def keyword for the builder we're serializing, i.e. 'def' or 'async def'"""
         ...
 
     @property
     @abstractmethod
-    def _def(self) -> str:
-        """The general definition of a function, i.e. def or async def"""
+    def _call_method(self) -> str:
+        """How to call network calls. Await if we have to await network calls"""
         ...
 
     @property
     @abstractmethod
-    def _want_inline_type_hints(self) -> bool:
-        """Whether you want inline type hints. If false, your type hints will be commented'"""
-        ...
-
-    @abstractmethod
-    def _response_type_annotation(
-        self, builder, modify_if_head_as_boolean: bool = True
-    ) -> str:
-        """The mypy type annotation for the response"""
-        ...
-
-    @abstractmethod
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        """Any wrappers that you want to go around the response type annotation"""
-        ...
-
-    @staticmethod
-    @abstractmethod
-    def _method_signature_and_response_type_annotation_template(
-        method_signature: str, response_type_annotation: str
-    ) -> str:
-        """Template for how to combine the method signature + the response type annotation together. Called by
-        method_signature_and_response_type_annotation"""
-        ...
-
-    @abstractmethod
-    def decorators(self, builder, async_mode: bool) -> List[str]:
-        """Decorators for the method"""
-        ...
-
-    @abstractmethod
-    def method_signature_and_response_type_annotation(
-        self, builder, async_mode: bool, *, want_decorators: Optional[bool] = True
-    ) -> str:
-        """Combines the method signature + the response type annotation together"""
-        ...
-
-    @abstractmethod
-    def description_and_summary(self, builder) -> List[str]:
-        """Description + summary from the swagger. Will be formatted into the overall operation description"""
+    def serializer_name(self) -> str:
         ...
 
     @abstractmethod
-    def response_docstring(self, builder) -> List[str]:
+    def response_docstring(self, builder: BuilderType) -> List[str]:
         """Response portion of the docstring"""
         ...
 
-    @abstractmethod
-    def want_example_template(self, builder) -> bool:
-        ...
-
-    @abstractmethod
-    def get_example_template(self, builder) -> List[str]:
-        ...
-
-    @abstractmethod
-    def _get_json_example_template(self, builder) -> List[str]:
-        ...
-
-    @abstractmethod
-    def _has_json_example_template(self, builder) -> bool:
-        ...
-
-    @abstractmethod
-    def _json_example_param_name(self, builder) -> str:
-        ...
-
-    @abstractmethod
-    def _get_json_response_template(self, builder) -> List[str]:
-        ...
-
-    @abstractmethod
-    def _get_json_response_template_to_status_codes(
-        self, builder
-    ) -> Dict[str, List[str]]:
-        ...
-
-    @abstractmethod
-    def _get_kwargs_to_pop(self, builder) -> List[Parameter]:
-        ...
-
-
-class _BuilderBaseSerializer(
-    _BuilderSerializerProtocol
-):  # pylint: disable=abstract-method
-    def __init__(self, code_model: CodeModel) -> None:
-        self.code_model = code_model
-
-    @property
-    def _cls_docstring_rtype(self) -> str:
-        return (
-            ""
-            if self.code_model.options["version_tolerant"]
-            else " or the result of cls(response)"
-        )
-
-    def decorators(self, builder, async_mode: bool) -> List[str]:
+    def decorators(self, builder: BuilderType) -> List[str]:
         """Decorators for the method"""
         retval: List[str] = []
+        if builder.is_overload:
+            return ["@overload"]
         if self.code_model.options["tracing"] and builder.want_tracing:
-            retval.append(f"@distributed_trace{'_async' if async_mode else ''}")
+            retval.append(f"@distributed_trace{'_async' if self.async_mode else ''}")
         return retval
 
-    def _method_signature(
-        self, builder: Operation, response_type_annotation: str
-    ) -> str:
-        return utils.serialize_method(
-            function_def=self._function_definition,
+    def _method_signature(self, builder: BuilderType) -> str:
+        return self.parameter_serializer.serialize_method(
+            function_def=self._function_def,
             method_name=builder.name,
-            is_in_class=self._is_in_class,
+            need_self_param=self._need_self_param,
             method_param_signatures=builder.method_signature(
-                self._want_inline_type_hints
+                self.async_mode or self.is_python3_file, self.async_mode
             ),
-            ignore_inconsistent_return_statements=(response_type_annotation == "None"),
+            pylint_disable=builder.pylint_disable,
         )
 
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        return []
-
     def method_signature_and_response_type_annotation(
-        self, builder, async_mode: bool, *, want_decorators: Optional[bool] = True
+        self, builder: BuilderType, *, want_decorators: Optional[bool] = True
     ) -> str:
-        response_type_annotation = self._response_type_annotation(builder)
-        # want pre-wrapped response type. As long as it's None, pylint will get mad about inconsistent return types
-        method_signature = self._method_signature(builder, response_type_annotation)
-        for wrapper in self._response_type_annotation_wrapper(builder)[::-1]:
-            response_type_annotation = f"{wrapper}[{response_type_annotation}]"
-        decorators = self.decorators(builder, async_mode)
+        response_type_annotation = builder.response_type_annotation(
+            async_mode=self.async_mode
+        )
+        method_signature = self._method_signature(builder)
+        decorators = self.decorators(builder)
         decorators_str = ""
         if decorators and want_decorators:
             decorators_str = "\n".join(decorators) + "\n"
         return (
             decorators_str
-            + self._method_signature_and_response_type_annotation_template(
-                method_signature, response_type_annotation
+            + utils.method_signature_and_response_type_annotation_template(
+                is_python3_file=self.is_python3_file,
+                method_signature=method_signature,
+                response_type_annotation=response_type_annotation,
             )
         )
 
-    def description_and_summary(self, builder) -> List[str]:
+    def description_and_summary(  # pylint: disable=no-self-use
+        self, builder: BuilderType
+    ) -> List[str]:
         description_list: List[str] = []
         description_list.append(
             f"{ builder.summary.strip() if builder.summary else builder.description.strip() }"
@@ -316,267 +264,195 @@ class _BuilderBaseSerializer(
         description_list.append("")
         return description_list
 
+    def example_template(self, builder: BuilderType) -> List[str]:
+        template = []
+        if builder.abstract:
+            return []
+        if self._json_input_example_template(builder):
+            template.append("")
+            template += self._json_input_example_template(builder)
+        return template
+
     def param_description(  # pylint: disable=no-self-use
-        self, builder: Union[RequestBuilder, Operation]
+        self, builder: BuilderType
     ) -> List[str]:
         description_list: List[str] = []
-        for param in [
-            m
-            for m in builder.parameters.method
-            if m.method_location != ParameterMethodLocation.HIDDEN_KWARG
-        ]:
+        for param in builder.parameters.method:
+            if not param.in_docstring:
+                continue
             description_list.extend(
-                f":{param.description_keyword} { param.serialized_name }: { param.description }".replace(
+                f":{param.description_keyword} { param.client_name }: { param.description }".replace(
                     "\n", "\n "
                 ).split(
                     "\n"
                 )
             )
+            docstring_type = param.docstring_type(async_mode=self.async_mode)
             description_list.append(
-                f":{param.docstring_type_keyword} { param.serialized_name }: { param.docstring_type }"
+                f":{param.docstring_type_keyword} {param.client_name}: {docstring_type}"
             )
-
-        if len(builder.parameters.content_types) > 1:
-            description_list = [
-                _content_type_docstring(builder)
-                if l.startswith(":keyword content_type:")
-                else l
-                for l in description_list
-            ]
-            if not any(
-                l for l in description_list if l.startswith(":keyword content_type:")
-            ):
-                description_list.append(_content_type_docstring(builder))
         return description_list
 
-    def param_description_and_response_docstring(self, builder) -> List[str]:
+    def param_description_and_response_docstring(
+        self, builder: BuilderType
+    ) -> List[str]:
         if builder.abstract:
             return []
         return self.param_description(builder) + self.response_docstring(builder)
 
-    def _get_json_response_template_to_status_codes(
-        self, builder
-    ) -> Dict[str, List[str]]:
-        # successful status codes of responses that have bodies
-        responses = [
-            response
-            for response in builder.responses
-            if any(
-                code in builder.success_status_code for code in response.status_codes
-            )
-            and isinstance(
-                response.schema,
-                (DictionarySchema, ListSchema, ObjectSchema, EnumSchema),
-            )
-        ]
-        retval = defaultdict(list)
-        for response in responses:
-            status_codes = [str(status_code) for status_code in response.status_codes]
-            response_json = _json_dumps_template(
-                cast(BaseSchema, response.schema).get_json_template_representation()
-            )
-            retval[response_json].extend(status_codes)
-        return retval
-
-    def get_example_template(self, builder) -> List[str]:
-        template = []
-        if self._has_json_example_template(builder):
-            template.append("")
-            template += self._get_json_example_template(builder)
-        if self._get_json_response_template_to_status_codes(builder):
-            template.append("")
-            template += self._get_json_response_template(builder)
-        return template
+    @property
+    @abstractmethod
+    def _json_response_template_name(self) -> str:
+        ...
 
-    def _get_json_example_template(self, builder) -> List[str]:
-        template = []
-        json_body = builder.parameters.json_body
-        object_schema = cast(ObjectSchema, json_body)
-        try:
-            discriminator_name = object_schema.discriminator_name
-            subtype_map = object_schema.subtype_map
-        except AttributeError:
-            discriminator_name = None
-            subtype_map = None
-        if subtype_map:
+    def _json_input_example_template(self, builder: BuilderType) -> List[str]:
+        template: List[str] = []
+        if self.code_model.options["models_mode"]:
+            # No input template if we have models
+            return template
+        if (
+            not builder.parameters.has_body
+            or builder.parameters.body_parameter.flattened
+        ):
+            # No input template if now body parameter
+            return template
+        if builder.overloads:
+            # if there's overloads, we do the json input example template on the overload
+            return template
+
+        body_param = builder.parameters.body_parameter
+        if not isinstance(body_param.type, (ListType, DictionaryType, ModelType)):
+            return template
+
+        polymorphic_subtypes: List[ModelType] = []
+        body_param.type.get_polymorphic_subtypes(polymorphic_subtypes)
+        if polymorphic_subtypes:
+            # we just assume one kind of polymorphic body for input
+            discriminator_name = cast(
+                Property, polymorphic_subtypes[0].discriminator
+            ).rest_api_name
             template.append(
-                "{} = '{}'".format(
-                    discriminator_name, "' or '".join(subtype_map.values())
-                )
+                "# The input is polymorphic. The following are possible polymorphic "
+                f'inputs based off discriminator "{discriminator_name}":'
             )
-            template.append("")
-
-        try:
-            property_with_discriminator = object_schema.property_with_discriminator
-        except AttributeError:
-            property_with_discriminator = None
-        if property_with_discriminator:
-            polymorphic_schemas = [
-                s
-                for s in self.code_model.sorted_schemas
-                if s.name in property_with_discriminator.schema.subtype_map.values()
-            ]
-            num_schemas = min(
-                self.code_model.options["polymorphic_examples"],
-                len(polymorphic_schemas),
-            )
-            for i in range(num_schemas):
-                schema = polymorphic_schemas[i]
-                polymorphic_property = _json_dumps_template(
-                    schema.get_json_template_representation(),
+            for idx in range(
+                min(
+                    self.code_model.options["polymorphic_examples"],
+                    len(polymorphic_subtypes),
                 )
+            ):
                 template.extend(
-                    f"{property_with_discriminator.name} = {polymorphic_property}".splitlines()
+                    _get_polymorphic_subtype_template(polymorphic_subtypes[idx])
                 )
-                if i != num_schemas - 1:
-                    template.append("# OR")
             template.append("")
         template.append(
             "# JSON input template you can fill out and use as your body input."
         )
         json_template = _json_dumps_template(
-            builder.parameters.json_body.get_json_template_representation(),
+            body_param.type.get_json_template_representation(),
         )
         template.extend(
-            f"{self._json_example_param_name(builder)} = {json_template}".splitlines()
+            f"{builder.parameters.body_parameter.client_name} = {json_template}".splitlines()
         )
         return template
 
-    @property
-    @abstractmethod
-    def serializer_name(self) -> str:
-        ...
-
     def _serialize_parameter(self, param: Parameter, kwarg_name: str) -> List[str]:
-        function_name = "header" if kwarg_name == "headers" else "query"
         set_parameter = "_{}['{}'] = {}".format(
             kwarg_name,
             param.rest_api_name,
-            utils.build_serialize_data_call(param, function_name, self.serializer_name),
+            self.parameter_serializer.serialize_parameter(param, self.serializer_name),
         )
-        if param.required:
+        if not param.optional:
             retval = [set_parameter]
         else:
             retval = [
-                f"if {param.full_serialized_name} is not None:",
+                f"if {param.full_client_name} is not None:",
                 f"    {set_parameter}",
             ]
         return retval
 
-    def _get_json_response_template(self, builder) -> List[str]:
-        template = []
-        for (
-            response_body,
-            status_codes,
-        ) in self._get_json_response_template_to_status_codes(builder).items():
-            template.append(
-                "# response body for status code(s): {}".format(", ".join(status_codes))
-            )
-            template.extend(f"response.json() == {response_body}".splitlines())
-        return template
-
-    def serialize_path(self, builder) -> List[str]:
-        return utils.serialize_path(builder.parameters.path, self.serializer_name)
-
-    @property
-    def _function_definition(self) -> str:
-        return self._def
+    def serialize_path(self, builder: BuilderType) -> List[str]:
+        return self.parameter_serializer.serialize_path(
+            builder.parameters.path, self.serializer_name
+        )
 
 
 ############################## REQUEST BUILDERS ##############################
 
 
-class _RequestBuilderBaseSerializer(
-    _BuilderBaseSerializer
+class RequestBuilderSerializer(
+    _BuilderBaseSerializer[RequestBuilderType]
 ):  # pylint: disable=abstract-method
-    def description_and_summary(self, builder) -> List[str]:
+    def description_and_summary(self, builder: RequestBuilderType) -> List[str]:
         retval = super().description_and_summary(builder)
         retval += [
-            "See https://aka.ms/azsdk/python/protocol/quickstart for how to incorporate this "
+            "See https://aka.ms/azsdk/dpcodegen/python/send_request for how to incorporate this "
             "request builder into your code flow.",
             "",
         ]
         return retval
 
+    @property
+    def _call_method(self) -> str:
+        return ""
+
     @property
     def serializer_name(self) -> str:
         return "_SERIALIZER"
 
+    @property
+    def _json_response_template_name(self) -> str:
+        return "response.json()"
+
     @staticmethod
-    def declare_non_inputtable_constants(builder) -> List[str]:
-        def _get_value(param: Parameter):
-            if param.location in [ParameterLocation.Header, ParameterLocation.Query]:
+    def declare_non_inputtable_constants(builder: RequestBuilderType) -> List[str]:
+        def _get_value(param):
+            param_type = cast(ConstantType, param.type)
+            if param.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]:
                 kwarg_dict = (
                     "headers"
-                    if param.location == ParameterLocation.Header
+                    if param.location == ParameterLocation.HEADER
                     else "params"
                 )
-                return f"_{kwarg_dict}.pop('{param.rest_api_name}', {param.constant_declaration})"
-            return f"{param.constant_declaration}"
+                return f"_{kwarg_dict}.pop('{param.rest_api_name}', {param_type.get_declaration()})"
+            return f"{param_type.get_declaration()}"
 
         return [
-            f"{p.serialized_name} = {_get_value(p)}"
+            f"{p.client_name} = {_get_value(p)}"
             for p in builder.parameters.constant
-            if p.original_parameter is None
-            and p.in_method_code
-            and not p.in_method_signature
+            if not p.in_method_signature
         ]
 
-    def want_example_template(self, builder) -> bool:
-        if builder.abstract:
-            return False
-        if self.code_model.options["builders_visibility"] != "public":
-            return False  # if we're not exposing rest layer, don't need to generate
-        if builder.parameters.has_body:
-            body_kwargs = set(builder.parameters.body_kwarg_names.keys())
-            return bool(body_kwargs.intersection({"json", "files", "data"}))
-        return bool(self._get_json_response_template_to_status_codes(builder))
-
     @property
-    def _def(self) -> str:
+    def _function_def(self) -> str:
         return "def"
 
     @property
-    def _is_in_class(self) -> bool:
+    def _need_self_param(self) -> bool:
         return False
 
-    def _response_type_annotation(
-        self, builder, modify_if_head_as_boolean: bool = True
-    ) -> str:
-        return "HttpRequest"
-
-    def response_docstring(self, builder) -> List[str]:
+    def response_docstring(self, builder: RequestBuilderType) -> List[str]:
         response_str = (
             f":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 "
+            + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
             + "incorporate this response into your code flow."
         )
         rtype_str = f":rtype: ~azure.core.rest.HttpRequest"
         return [response_str, rtype_str]
 
-    def _json_example_param_name(self, builder) -> str:
-        return "json"
-
-    def _has_json_example_template(self, builder) -> bool:
-        return "json" in builder.parameters.body_kwarg_names
-
-    @abstractmethod
-    def _body_params_to_pass_to_request_creation(self, builder) -> List[str]:
-        ...
-
-    def pop_kwargs_from_signature(self, builder) -> List[str]:
-        return utils.pop_kwargs_from_signature(
-            self._get_kwargs_to_pop(builder),
+    def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
+        return self.parameter_serializer.pop_kwargs_from_signature(
+            builder.parameters.kwargs_to_pop(is_python3_file=self.is_python3_file),
             check_kwarg_dict=True,
-            pop_headers_kwarg=utils.PopKwargType.CASE_INSENSITIVE
+            pop_headers_kwarg=PopKwargType.CASE_INSENSITIVE
             if bool(builder.parameters.headers)
-            else utils.PopKwargType.NO,
-            pop_params_kwarg=utils.PopKwargType.CASE_INSENSITIVE
+            else PopKwargType.NO,
+            pop_params_kwarg=PopKwargType.CASE_INSENSITIVE
             if bool(builder.parameters.query)
-            else utils.PopKwargType.NO,
+            else PopKwargType.NO,
         )
 
-    def create_http_request(self, builder) -> List[str]:
+    def create_http_request(self, builder: RequestBuilderType) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
         retval.append("    url=_url,")
@@ -584,20 +460,25 @@ class _RequestBuilderBaseSerializer(
             retval.append("    params=_params,")
         if builder.parameters.headers:
             retval.append("    headers=_headers,")
-        if builder.parameters.has_body:
-            retval.extend(
-                [
-                    f"    {body_kwarg}={body_kwarg},"
-                    for body_kwarg in self._body_params_to_pass_to_request_creation(
-                        builder
-                    )
-                ]
-            )
+        if (
+            builder.parameters.has_body
+            and builder.parameters.body_parameter.in_method_signature
+        ):
+            body_param = builder.parameters.body_parameter
+            if body_param.constant or (
+                self.is_python3_file
+                and body_param.method_location != ParameterMethodLocation.KWARG
+            ):
+                # we only need to pass it through if it's not a kwarg or it's a popped kwarg
+                retval.append(
+                    f"    {builder.parameters.body_parameter.client_name}="
+                    f"{builder.parameters.body_parameter.client_name},"
+                )
         retval.append("    **kwargs")
         retval.append(")")
         return retval
 
-    def serialize_headers(self, builder) -> List[str]:
+    def serialize_headers(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct headers"]
         for parameter in builder.parameters.headers:
             retval.extend(
@@ -608,7 +489,7 @@ class _RequestBuilderBaseSerializer(
             )
         return retval
 
-    def serialize_query(self, builder) -> List[str]:
+    def serialize_query(self, builder: RequestBuilderType) -> List[str]:
         retval = ["# Construct parameters"]
         for parameter in builder.parameters.query:
             retval.extend(
@@ -619,7 +500,7 @@ class _RequestBuilderBaseSerializer(
             )
         return retval
 
-    def construct_url(self, builder) -> str:
+    def construct_url(self, builder: RequestBuilderType) -> str:
         if any(
             o
             for o in ["low_level_client", "version_tolerant"]
@@ -631,74 +512,13 @@ class _RequestBuilderBaseSerializer(
         return f"_url = {url_value}{'  # pylint: disable=line-too-long' if len(url_value) > 114 else ''}"
 
 
-class RequestBuilderGenericSerializer(_RequestBuilderBaseSerializer):
-    @property
-    def _want_inline_type_hints(self) -> bool:
-        return False
-
-    @staticmethod
-    def _method_signature_and_response_type_annotation_template(
-        method_signature: str, response_type_annotation: str
-    ):
-        return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=False,
-            method_signature=method_signature,
-            response_type_annotation=response_type_annotation,
-        )
-
-    def _get_kwargs_to_pop(self, builder):
-        return builder.parameters.kwargs_to_pop(is_python3_file=False)
-
-    def _body_params_to_pass_to_request_creation(self, builder) -> List[str]:
-        if any(
-            b
-            for b in builder.parameters.body
-            if b.constant and not (b.is_data_input or b.is_multipart)
-        ):
-            # this means we have a constant body
-            # only doing json body in this case
-            return ["json"]
-        return []
-
-
-class RequestBuilderPython3Serializer(_RequestBuilderBaseSerializer):
-    @property
-    def _want_inline_type_hints(self) -> bool:
-        return True
-
-    @staticmethod
-    def _method_signature_and_response_type_annotation_template(
-        method_signature: str, response_type_annotation: str
-    ):
-        return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=True,
-            method_signature=method_signature,
-            response_type_annotation=response_type_annotation,
-        )
-
-    def _get_kwargs_to_pop(self, builder):
-        return builder.parameters.kwargs_to_pop(is_python3_file=True)
-
-    def _body_params_to_pass_to_request_creation(self, builder) -> List[str]:
-        body_kwargs = list(builder.parameters.body_kwarg_names.keys())
-        if body_kwargs:
-            return body_kwargs
-        if any(
-            b
-            for b in builder.parameters.body
-            if b.constant and not (b.is_data_input or b.is_multipart)
-        ):
-            return ["json"]
-        return body_kwargs
-
-
 ############################## NORMAL OPERATIONS ##############################
 
 
-class _OperationBaseSerializer(
-    _BuilderBaseSerializer
+class _OperationSerializer(
+    _BuilderBaseSerializer[OperationType]
 ):  # pylint: disable=abstract-method
-    def description_and_summary(self, builder) -> List[str]:
+    def description_and_summary(self, builder: OperationType) -> List[str]:
         retval = super().description_and_summary(builder)
         if builder.deprecated:
             retval.append(".. warning::")
@@ -707,26 +527,82 @@ class _OperationBaseSerializer(
         return retval
 
     @property
-    def _is_in_class(self) -> bool:
+    def _json_response_template_name(self) -> str:
+        return "response"
+
+    def example_template(self, builder: OperationType) -> List[str]:
+        retval = super().example_template(builder)
+        if self.code_model.options["models_mode"]:
+            return retval
+        for response in builder.responses:
+            polymorphic_subtypes: List[ModelType] = []
+            if not response.type:
+                continue
+            response.type.get_polymorphic_subtypes(polymorphic_subtypes)
+            if polymorphic_subtypes:
+                # we just assume one kind of polymorphic body for input
+                discriminator_name = cast(
+                    Property, polymorphic_subtypes[0].discriminator
+                ).rest_api_name
+                retval.append(
+                    "# The response is polymorphic. The following are possible polymorphic "
+                    f'responses based off discriminator "{discriminator_name}":'
+                )
+                for idx in range(
+                    min(
+                        self.code_model.options["polymorphic_examples"],
+                        len(polymorphic_subtypes),
+                    )
+                ):
+                    retval.extend(
+                        _get_polymorphic_subtype_template(polymorphic_subtypes[idx])
+                    )
+
+        if _get_json_response_template_to_status_codes(builder):
+            retval.append("")
+            for (
+                response_body,
+                status_codes,
+            ) in _get_json_response_template_to_status_codes(builder).items():
+                retval.append(
+                    "# response body for status code(s): {}".format(
+                        ", ".join(status_codes)
+                    )
+                )
+                retval.extend(
+                    f"{self._json_response_template_name} == {response_body}".splitlines()
+                )
+        return retval
+
+    def make_pipeline_call(self, builder: OperationType) -> List[str]:
+        return [
+            f"pipeline_response = {self._call_method}self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access",
+            "    request,",
+            f"    stream={builder.has_stream_response},",
+            "    **kwargs",
+            ")",
+        ]
+
+    @property
+    def _function_def(self) -> str:
+        return "async def" if self.async_mode else "def"
+
+    @property
+    def _need_self_param(self) -> bool:
         return True
 
     @property
     def serializer_name(self) -> str:
         return "self._serialize"
 
-    def decorators(self, builder, async_mode: bool) -> List[str]:
+    def decorators(self, builder: OperationType) -> List[str]:
         """Decorators for the method"""
-        super_decorators = super().decorators(builder, async_mode)
-        if builder.abstract:
-            super_decorators.append("@abc.abstractmethod")
+        super_decorators = super().decorators(builder)
         return super_decorators
 
-    def _response_docstring_type_wrapper(  # pylint: disable=unused-argument, no-self-use
-        self, builder
-    ) -> List[str]:
-        return []
-
-    def param_description(self, builder) -> List[str]:  # pylint: disable=no-self-use
+    def param_description(
+        self, builder: OperationType
+    ) -> List[str]:  # pylint: disable=no-self-use
         description_list = super().param_description(builder)
         if not self.code_model.options["version_tolerant"]:
             description_list.append(
@@ -734,308 +610,261 @@ class _OperationBaseSerializer(
             )
         return description_list
 
-    def _response_docstring_type_template(self, builder) -> str:
-        retval = "{}"
-        for wrapper in self._response_docstring_type_wrapper(builder)[::-1]:
-            retval = f"{wrapper}[{retval}]"
-        return retval
-
-    def _response_type_annotation(
-        self, builder, modify_if_head_as_boolean: bool = True
-    ) -> str:
-        if (
-            modify_if_head_as_boolean
-            and builder.request_builder.method.lower() == "head"
-            and self.code_model.options["head_as_boolean"]
-        ):
-            return "bool"
-        response_body_annotations: OrderedSet[str] = {}
-        for response in [r for r in builder.responses if r.has_body]:
-            response_body_annotations[
-                response.type_annotation(is_operation_file=True)
-            ] = None
-        response_str = ", ".join(response_body_annotations.keys()) or "None"
-        if len(response_body_annotations) > 1:
-            response_str = f"Union[{response_str}]"
-        if builder.has_optional_return_type:
-            response_str = f"Optional[{response_str}]"
-        return response_str
-
-    def pop_kwargs_from_signature(self, builder) -> List[str]:
-        kwargs_to_pop = self._get_kwargs_to_pop(builder)
-        kwargs = utils.pop_kwargs_from_signature(
+    def pop_kwargs_from_signature(self, builder: OperationType) -> List[str]:
+        kwargs_to_pop = builder.parameters.kwargs_to_pop(
+            is_python3_file=self.is_python3_file
+        )
+        kwargs = self.parameter_serializer.pop_kwargs_from_signature(
             kwargs_to_pop,
             check_kwarg_dict=True,
-            pop_headers_kwarg=utils.PopKwargType.CASE_INSENSITIVE
+            pop_headers_kwarg=PopKwargType.CASE_INSENSITIVE
             if builder.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.Header
+                kwargs_to_pop, ParameterLocation.HEADER
             )
-            else utils.PopKwargType.SIMPLE,
-            pop_params_kwarg=utils.PopKwargType.CASE_INSENSITIVE
+            else PopKwargType.SIMPLE,
+            pop_params_kwarg=PopKwargType.CASE_INSENSITIVE
             if builder.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.Query
+                kwargs_to_pop, ParameterLocation.QUERY
             )
-            else utils.PopKwargType.SIMPLE,
+            else PopKwargType.SIMPLE,
+            check_client_input=not self.code_model.options["multiapi"],
         )
         kwargs.append(
             f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}"
         )
         return kwargs
 
-    def cls_type_annotation(self, builder) -> str:
-        return f"# type: ClsType[{self._response_type_annotation(builder, modify_if_head_as_boolean=False)}]"
+    def cls_type_annotation(self, builder: OperationType) -> str:
+        return f"# type: {builder.cls_type_annotation(async_mode=self.async_mode)}"
 
-    def _response_docstring_text_template(  # pylint: disable=no-self-use, unused-argument
-        self, builder
-    ) -> str:
-        cls_str = f",{self._cls_docstring_rtype}" if self._cls_docstring_rtype else ""
-        return "{}" + cls_str
-
-    def response_docstring(self, builder) -> List[str]:
-        responses_with_body = [r for r in builder.responses if r.has_body]
-        if (
-            builder.request_builder.method.lower() == "head"
-            and self.code_model.options["head_as_boolean"]
-        ):
-            response_docstring_text = "bool"
-            rtype = "bool"
-        elif responses_with_body:
-            response_body_docstring_text: OrderedSet[str] = {
-                response.docstring_text: None for response in responses_with_body
-            }
-            response_docstring_text = " or ".join(response_body_docstring_text.keys())
-            response_body_docstring_type: OrderedSet[str] = {
-                response.docstring_type: None for response in responses_with_body
-            }
-            rtype = " or ".join(response_body_docstring_type.keys())
-            if builder.has_optional_return_type:
-                rtype += " or None"
-        else:
-            response_docstring_text = "None"
-            rtype = "None"
-        response_str = f":return: {self._response_docstring_text_template(builder).format(response_docstring_text)}"
+    def response_docstring(self, builder: OperationType) -> List[str]:
+        response_str = (
+            f":return: {builder.response_docstring_text(async_mode=self.async_mode)}"
+        )
         rtype_str = (
-            f":rtype: {self._response_docstring_type_template(builder).format(rtype)}"
+            f":rtype: {builder.response_docstring_type(async_mode=self.async_mode)}"
         )
         return [
             response_str,
             rtype_str,
-            ":raises: ~azure.core.exceptions.HttpResponseError",
+            ":raises ~azure.core.exceptions.HttpResponseError:",
         ]
 
-    def want_example_template(self, builder) -> bool:
-        if builder.abstract:
-            return False
-        if self.code_model.options["models_mode"]:
-            return False
-        if builder.parameters.has_body:
-            body_params = builder.parameters.body
-            return any(
-                [
-                    b
-                    for b in body_params
-                    if isinstance(
-                        b.schema, (DictionarySchema, ListSchema, ObjectSchema)
-                    )
-                ]
-            )
-        return bool(self._get_json_response_template_to_status_codes(builder))
-
-    def _json_example_param_name(self, builder) -> str:
-        return builder.parameters.body[0].serialized_name
-
-    def _has_json_example_template(self, builder) -> bool:
-        return builder.parameters.has_body
+    def _serialize_body_parameter(self, builder: OperationType) -> List[str]:
+        """We need to serialize params if they're not meant to be streamed in.
 
-    def _serialize_body_call(
-        self,
-        builder,
-        body_param: Parameter,
-        send_xml: bool,
-        ser_ctxt: Optional[str],
-        ser_ctxt_name: str,
-    ) -> str:
-        body_is_xml = ", is_xml=True" if send_xml else ""
-        pass_ser_ctxt = f", {ser_ctxt_name}={ser_ctxt_name}" if ser_ctxt else ""
-        body_kwarg_to_pass = builder.body_kwargs_to_pass_to_request_builder[0]
+        This function serializes the body params that need to be serialized.
+        """
+        retval: List[str] = []
+        body_param = cast(BodyParameter, builder.parameters.body_parameter)
+        body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
+        send_xml = builder.parameters.body_parameter.type.is_xml
+        xml_serialization_ctxt = (
+            body_param.type.xml_serialization_ctxt if send_xml else None
+        )
+        ser_ctxt_name = "serialization_ctxt"
+        if xml_serialization_ctxt and self.code_model.options["models_mode"]:
+            retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
         if self.code_model.options["models_mode"]:
-            return (
-                f"_{body_kwarg_to_pass} = self._serialize.body({body_param.serialized_name}, "
-                f"'{ body_param.serialization_type }'{body_is_xml}{ pass_ser_ctxt })"
+            is_xml_cmd = ", is_xml=True" if send_xml else ""
+            serialization_ctxt_cmd = (
+                f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
+            )
+            create_body_call = (
+                f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
+                f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
-        return f"_{body_kwarg_to_pass} = {body_param.serialized_name}"
+        else:
+            create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
+        if body_param.optional:
+            retval.append(f"if {body_param.client_name} is not None:")
+            retval.append("    " + create_body_call)
+            retval.append("else:")
+            retval.append(f"    _{body_kwarg_name} = None")
+        else:
+            retval.append(create_body_call)
+        return retval
 
-    def _serialize_body(
-        self, builder, body_param: Parameter, body_kwarg: str
+    def _create_body_parameter(
+        self,
+        builder: OperationType,
     ) -> List[str]:
+        """Create the body parameter before we pass it as either json or content to the request builder"""
         retval = []
-        send_xml = bool(
-            builder.parameters.has_body
-            and any(["xml" in ct for ct in builder.parameters.content_types])
-            and not isinstance(body_param.schema, IOSchema)
-        )
-        ser_ctxt_name = "serialization_ctxt"
-        ser_ctxt = (
-            builder.parameters.body[0].xml_serialization_ctxt if send_xml else None
-        )
-        if ser_ctxt and self.code_model.options["models_mode"]:
-            retval.append(f'{ser_ctxt_name} = {{"xml": {{{ser_ctxt}}}}}')
-        serialize_body_call = self._serialize_body_call(
-            builder,
-            body_param,
-            send_xml,
-            ser_ctxt,
-            ser_ctxt_name,
-        )
-        if body_param.required:
-            retval.append(serialize_body_call)
+        body_param = cast(BodyParameter, builder.parameters.body_parameter)
+        if hasattr(body_param, "entries"):
+            return _serialize_multipart_body(builder)
+        body_kwarg_name = builder.request_builder.parameters.body_parameter.client_name
+        if isinstance(body_param.type, BinaryType):
+            retval.append(f"_{body_kwarg_name} = {body_param.client_name}")
+            if (
+                not body_param.default_content_type
+                and not next(
+                    p for p in builder.parameters if p.rest_api_name == "Content-Type"
+                ).optional
+            ):
+                content_types = "'" + "', '".join(body_param.content_types) + "'"
+                retval.extend(
+                    [
+                        "if not content_type:",
+                        f'    raise TypeError("Missing required keyword-only argument: content_type. '
+                        f'Known values are:" + "{content_types}")',
+                    ]
+                )
         else:
-            retval.append(f"if {body_param.serialized_name} is not None:")
-            retval.append("    " + serialize_body_call)
-            if len(builder.body_kwargs_to_pass_to_request_builder) == 1:
-                retval.append("else:")
-                retval.append(f"    _{body_kwarg} = None")
+            retval.extend(self._serialize_body_parameter(builder))
         return retval
 
-    def _set_body_content_kwarg(
-        self, builder, body_param: Parameter, body_kwarg: Parameter
-    ) -> List[str]:
+    def _initialize_overloads(self, builder: OperationType) -> List[str]:
         retval: List[str] = []
-        if (
-            body_kwarg.serialized_name == "data"
-            or body_kwarg.serialized_name == "files"
-        ):
-            return retval
+        same_content_type = (
+            len(
+                set(
+                    o.parameters.body_parameter.default_content_type
+                    for o in builder.overloads
+                )
+            )
+            == 1
+        )
+        if same_content_type:
+            default_content_type = builder.overloads[
+                0
+            ].parameters.body_parameter.default_content_type
+            retval.append(f'content_type = content_type or "{default_content_type}"')
+        for overload in builder.overloads:
+            retval.append(
+                f"_{overload.request_builder.parameters.body_parameter.client_name} = None"
+            )
         try:
-            if not body_param.style == ParameterStyle.binary:
-                retval.extend(
-                    self._serialize_body(
-                        builder, body_param, body_kwarg.serialized_name
+            # if there is a binary overload, we do a binary check first.
+            binary_overload = cast(
+                OperationType,
+                next(
+                    (
+                        o
+                        for o in builder.overloads
+                        if isinstance(o.parameters.body_parameter.type, BinaryType)
                     )
+                ),
+            )
+            binary_body_param = binary_overload.parameters.body_parameter
+            retval.append(
+                f"if {binary_body_param.type.instance_check_template.format(binary_body_param.client_name)}:"
+            )
+            if binary_body_param.default_content_type and not same_content_type:
+                retval.append(
+                    f'    content_type = content_type or "{binary_body_param.default_content_type}"'
                 )
-                return retval
-        except AttributeError:
-            pass
-        retval.append(f"_{body_kwarg.serialized_name} = {body_param.serialized_name}")
-        return retval
-
-    def _serialize_body_parameters(
-        self,
-        builder,
-    ) -> List[str]:
-        retval = []
-        body_kwargs = [
-            p for p in builder.request_builder.parameters.body if p.content_types
-        ]
-        builder_params = []
-        if builder.parameters.has_body:
-            builder_params += builder.parameters.body
-        if builder.multiple_content_type_parameters.has_body:
-            builder_params += builder.multiple_content_type_parameters.body
-        if len(body_kwargs) == 1:
             retval.extend(
-                self._set_body_content_kwarg(
-                    builder, builder.parameters.body[0], body_kwargs[0]
-                )
+                f"    {l}" for l in self._create_body_parameter(binary_overload)
             )
-        else:
-            retval.append('content_type = content_type or ""')
-            for idx, body_kwarg in enumerate(body_kwargs):
-                body_param = next(
-                    b for b in builder_params if body_kwarg in b.body_kwargs
+            retval.append("else:")
+            other_overload = cast(
+                OperationType,
+                next(
+                    (
+                        o
+                        for o in builder.overloads
+                        if not isinstance(o.parameters.body_parameter.type, BinaryType)
+                    )
+                ),
+            )
+            retval.extend(
+                f"    {l}" for l in self._create_body_parameter(other_overload)
+            )
+            if (
+                other_overload.parameters.body_parameter.default_content_type
+                and not same_content_type
+            ):
+                retval.append(
+                    "    content_type = content_type or "
+                    f'"{other_overload.parameters.body_parameter.default_content_type}"'
                 )
+        except StopIteration:
+            for idx, overload in enumerate(builder.overloads):
                 if_statement = "if" if idx == 0 else "elif"
+                body_param = overload.parameters.body_parameter
                 retval.append(
-                    f'{if_statement} content_type.split(";")[0] in {body_kwarg.pre_semicolon_content_types}:'
+                    f"{if_statement} {body_param.type.instance_check_template.format(body_param.client_name)}:"
                 )
+                if body_param.default_content_type and not same_content_type:
+                    retval.append(
+                        f'    content_type = content_type or "{body_param.default_content_type}"'
+                    )
                 retval.extend(
-                    [
-                        "    " + line
-                        for line in self._set_body_content_kwarg(
-                            builder, body_param, body_kwarg
-                        )
-                    ]
+                    f"    {l}"
+                    for l in self._create_body_parameter(cast(OperationType, overload))
                 )
-            retval.extend(_content_type_error_check(builder))
-
         return retval
 
-    def _call_request_builder_helper(  # pylint: disable=too-many-statements
+    def _create_request_builder_call(
         self,
-        builder,
-        request_builder: RequestBuilder,
+        builder: OperationType,
+        request_builder: RequestBuilderType,
         template_url: Optional[str] = None,
         is_next_request: bool = False,
     ) -> List[str]:
-        retval = []
-        if len(builder.body_kwargs_to_pass_to_request_builder) > 1:
-            # special case for files, bc we hardcode body param to be called 'files' for multipart
-            body_params_to_initialize = builder.body_kwargs_to_pass_to_request_builder
-            if self.code_model.options["version_tolerant"]:
-                body_params_to_initialize = [
-                    p for p in body_params_to_initialize if p != "files"
-                ]
-            for k in body_params_to_initialize:
-                retval.append(f"_{k} = None")
-        if builder.parameters.grouped:
-            # request builders don't allow grouped parameters, so we group them before making the call
-            retval.extend(_serialize_grouped_body(builder))
-
-        if builder.parameters.is_flattened:
-            # unflatten before passing to request builder as well
-            retval.extend(_serialize_flattened_body(builder))
-        if request_builder.multipart or request_builder.parameters.data_inputs:
-            if not self.code_model.options["version_tolerant"]:
-                param_name = "_files" if request_builder.multipart else "_data"
-                retval.extend(_serialize_files_and_data_body(builder, param_name))
-        elif builder.parameters.has_body and not builder.parameters.body[0].constant:
-            retval.extend(self._serialize_body_parameters(builder))
-
+        retval: List[str] = []
         if self.code_model.options["builders_visibility"] == "embedded":
             request_path_name = request_builder.name
         else:
-            builder_group_name = request_builder.builder_group_name
+            group_name = request_builder.group_name
             request_path_name = "rest{}.{}".format(
-                ("_" + builder_group_name) if builder_group_name else "",
+                ("_" + group_name) if group_name else "",
                 request_builder.name,
             )
-        retval.append("")
         retval.append(f"request = {request_path_name}(")
         for parameter in request_builder.parameters.method:
-            if (
-                parameter.is_body
-                and not parameter.constant
-                and parameter.serialized_name
-                not in builder.body_kwargs_to_pass_to_request_builder
-            ):
+            if parameter.location == ParameterLocation.BODY:
+                # going to pass in body later based off of overloads
                 continue
             if (
                 is_next_request
-                and not bool(builder.next_request_builder)
+                and builder.operation_type == "paging"
+                and not bool(builder.next_request_builder)  # type: ignore
                 and not self.code_model.options["reformat_next_link"]
-                and parameter.location == ParameterLocation.Query
+                and parameter.location == ParameterLocation.QUERY
             ):
                 # if we don't want to reformat query parameters for next link calls
                 # in paging operations with a single swagger operation defintion,
                 # we skip passing query params when building the next request
                 continue
-            high_level_name = cast(
-                RequestBuilderParameter, parameter
-            ).name_in_high_level_operation
-            retval.append(f"    {parameter.serialized_name}={high_level_name},")
+            retval.append(
+                f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
+            )
+        if request_builder.overloads:
+            for overload in request_builder.overloads:
+                body_param = cast(
+                    RequestBuilderBodyParameter, overload.parameters.body_parameter
+                )
+                retval.append(
+                    f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
+                )
+        elif request_builder.parameters.has_body:
+            body_param = cast(
+                RequestBuilderBodyParameter, request_builder.parameters.body_parameter
+            )
+            retval.append(
+                f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
+            )
         if not self.code_model.options["version_tolerant"]:
-            if builder.parameters.multipart:
-                retval.append(f"    files=_files,")
-            if builder.parameters.data_inputs:
-                retval.append(f"    data=_data,")
             template_url = template_url or f"self.{builder.name}.metadata['url']"
             retval.append(f"    template_url={template_url},")
         retval.append("    headers=_headers,")
         retval.append("    params=_params,")
         retval.append(f")")
+        return retval
+
+    def _postprocess_http_request(
+        self, builder: OperationType, template_url: Optional[str] = None
+    ) -> List[str]:
+        retval: List[str] = []
         if not self.code_model.options["version_tolerant"]:
             pass_files = ""
-            if builder.parameters.multipart:
+            if (
+                builder.parameters.has_body
+                and builder.parameters.body_parameter.client_name == "files"
+            ):
                 pass_files = ", _files"
             retval.append(f"request = _convert_request(request{pass_files})")
         if builder.parameters.path:
@@ -1051,17 +880,46 @@ class _OperationBaseSerializer(
         )
         return retval
 
-    def call_request_builder(self, builder) -> List[str]:
+    def _call_request_builder_helper(  # pylint: disable=too-many-statements
+        self,
+        builder: OperationType,
+        request_builder: RequestBuilderType,
+        template_url: Optional[str] = None,
+        is_next_request: bool = False,
+    ) -> List[str]:
+        retval = []
+        if builder.parameters.grouped:
+            # request builders don't allow grouped parameters, so we group them before making the call
+            retval.extend(_serialize_grouped_body(builder))
+        if builder.parameters.has_body and builder.parameters.body_parameter.flattened:
+            # unflatten before passing to request builder as well
+            retval.extend(_serialize_flattened_body(builder.parameters.body_parameter))
+        if builder.overloads:
+            # we are only dealing with two overloads. If there are three, we generate an abstract operation
+            retval.extend(self._initialize_overloads(builder))
+        elif builder.parameters.has_body:
+            # non-overloaded body
+            retval.extend(self._create_body_parameter(builder))
+        retval.append("")
+        retval.extend(
+            self._create_request_builder_call(
+                builder, request_builder, template_url, is_next_request
+            )
+        )
+        retval.extend(self._postprocess_http_request(builder, template_url))
+        return retval
+
+    def call_request_builder(self, builder: OperationType) -> List[str]:
         return self._call_request_builder_helper(builder, builder.request_builder)
 
     def response_headers_and_deserialization(
         self,
-        response: SchemaResponse,
+        response: Response,
     ) -> List[str]:
         retval: List[str] = [
             (
-                f"response_headers['{response_header.name}']=self._deserialize('{response_header.serialization_type}', "
-                f"response.headers.get('{response_header.name}'))"
+                f"response_headers['{response_header.rest_api_name}']=self._deserialize("
+                f"'{response_header.serialization_type}', response.headers.get('{response_header.rest_api_name}'))"
             )
             for response_header in response.headers
         ]
@@ -1070,20 +928,21 @@ class _OperationBaseSerializer(
         if response.is_stream_response:
             retval.append(
                 "deserialized = {}".format(
-                    "response"
+                    "response.iter_bytes()"
                     if self.code_model.options["version_tolerant"]
                     else "response.stream_download(self._client._pipeline)"
                 )
             )
-        elif response.has_body:
+        elif response.type:
             if self.code_model.options["models_mode"]:
                 retval.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
             else:
-                is_xml = any(["xml" in ct for ct in response.content_types])
                 deserialized_value = (
-                    "ET.fromstring(response.text())" if is_xml else "response.json()"
+                    "ET.fromstring(response.text())"
+                    if response.type.is_xml
+                    else "response.json()"
                 )
                 retval.append(f"if response.content:")
                 retval.append(f"    deserialized = {deserialized_value}")
@@ -1091,20 +950,21 @@ class _OperationBaseSerializer(
                 retval.append(f"    deserialized = None")
         return retval
 
-    @property
-    @abstractmethod
-    def _call_method(self) -> str:
-        ...
-
-    def handle_error_response(self, builder) -> List[str]:
-        retval = [f"if response.status_code not in {str(builder.success_status_code)}:"]
+    def handle_error_response(self, builder: OperationType) -> List[str]:
+        retval = [
+            f"if response.status_code not in {str(builder.success_status_codes)}:"
+        ]
         retval.append(
             "    map_error(status_code=response.status_code, response=response, error_map=error_map)"
         )
         error_model = ""
-        if builder.default_exception and self.code_model.options["models_mode"]:
+        if (
+            builder.default_error_deserialization
+            and self.code_model.options["models_mode"]
+        ):
             retval.append(
-                f"    error = self._deserialize.failsafe_deserialize({builder.default_exception}, pipeline_response)"
+                f"    error = self._deserialize.failsafe_deserialize({builder.default_error_deserialization}, "
+                "pipeline_response)"
             )
             error_model = ", model=error"
         retval.append(
@@ -1117,7 +977,7 @@ class _OperationBaseSerializer(
         )
         return retval
 
-    def handle_response(self, builder) -> List[str]:
+    def handle_response(self, builder: OperationType) -> List[str]:
         retval: List[str] = ["response = pipeline_response.http_response"]
         retval.append("")
         retval.extend(self.handle_error_response(builder))
@@ -1128,9 +988,9 @@ class _OperationBaseSerializer(
             retval.append("response_headers = {}")
         if builder.has_response_body or builder.any_response_has_headers:
             if len(builder.responses) > 1:
-                for status_code in builder.success_status_code:
+                for status_code in builder.success_status_codes:
                     response = builder.get_response_from_status(status_code)
-                    if response.headers or response.has_body:
+                    if response.headers or response.type:
                         retval.append(f"if response.status_code == {status_code}:")
                         retval.extend(
                             [
@@ -1149,9 +1009,7 @@ class _OperationBaseSerializer(
         if builder.has_optional_return_type or self.code_model.options["models_mode"]:
             deserialized = "deserialized"
         else:
-            deserialized = (
-                f"cast({self._response_type_annotation(builder)}, deserialized)"
-            )
+            deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
         retval.append("if cls:")
         retval.append(
             "    return cls(pipeline_response, {}, {})".format(
@@ -1169,23 +1027,22 @@ class _OperationBaseSerializer(
             retval.append("return 200 <= response.status_code <= 299")
         return retval
 
-    def error_map(self, builder) -> List[str]:
+    def error_map(self, builder: OperationType) -> List[str]:
         retval = ["error_map = {"]
-        if builder.status_code_exceptions:
-            if not 401 in builder.status_code_exceptions_status_codes:
+        if builder.non_default_errors:
+            if not 401 in builder.non_default_error_status_codes:
                 retval.append("    401: ClientAuthenticationError,")
-            if not 404 in builder.status_code_exceptions_status_codes:
+            if not 404 in builder.non_default_error_status_codes:
                 retval.append("    404: ResourceNotFoundError,")
-            if not 409 in builder.status_code_exceptions_status_codes:
+            if not 409 in builder.non_default_error_status_codes:
                 retval.append("    409: ResourceExistsError,")
-            for excep in builder.status_code_exceptions:
+            for excep in builder.non_default_errors:
                 error_model_str = ""
                 if (
-                    isinstance(excep.schema, ObjectSchema)
-                    and excep.is_exception
+                    isinstance(excep.type, ModelType)
                     and self.code_model.options["models_mode"]
                 ):
-                    error_model_str = f", model=self._deserialize(_models.{excep.serialization_type}, response)"
+                    error_model_str = f", model=self._deserialize(_models.{excep.type.serialization_type}, response)"
                 error_format_str = (
                     ", error_format=ARMErrorFormat"
                     if self.code_model.options["azure_arm"]
@@ -1223,108 +1080,53 @@ class _OperationBaseSerializer(
         return retval
 
     @staticmethod
-    def get_metadata_url(builder) -> str:
+    def get_metadata_url(builder: OperationType) -> str:
         url = _escape_str(builder.request_builder.url)
-        return f"{builder.python_name}.metadata = {{'url': { url }}}  # type: ignore"
-
-
-class _SyncOperationBaseSerializer(
-    _OperationBaseSerializer
-):  # pylint: disable=abstract-method
-    @property
-    def _want_inline_type_hints(self) -> bool:
-        return False
-
-    @property
-    def _def(self) -> str:
-        return "def"
+        return f"{builder.name}.metadata = {{'url': { url }}}  # type: ignore"
 
     @property
     def _call_method(self) -> str:
-        return ""
+        return "await " if self.async_mode else ""
 
 
-class SyncOperationGenericSerializer(_SyncOperationBaseSerializer):
-    @property
-    def _want_inline_type_hints(self) -> bool:
-        return False
-
-    @staticmethod
-    def _method_signature_and_response_type_annotation_template(
-        method_signature: str, response_type_annotation: str
-    ):
-        return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=False,
-            method_signature=method_signature,
-            response_type_annotation=response_type_annotation,
-        )
-
-    def _get_kwargs_to_pop(self, builder):
-        return builder.parameters.kwargs_to_pop(is_python3_file=False)
-
-
-class SyncOperationPython3Serializer(_SyncOperationBaseSerializer):
-    @property
-    def _want_inline_type_hints(self) -> bool:
-        return True
-
-    @staticmethod
-    def _method_signature_and_response_type_annotation_template(
-        method_signature: str, response_type_annotation: str
-    ):
-        return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=True,
-            method_signature=method_signature,
-            response_type_annotation=response_type_annotation,
-        )
-
-    def _get_kwargs_to_pop(self, builder):
-        return builder.parameters.kwargs_to_pop(is_python3_file=True)
-
-
-class AsyncOperationSerializer(SyncOperationPython3Serializer):
-    @property
-    def _def(self) -> str:
-        return "async def"
-
-    @property
-    def _function_definition(self) -> str:
-        return "async def"
-
-    @property
-    def _call_method(self) -> str:
-        return "await "
+class OperationSerializer(_OperationSerializer[Operation]):
+    ...
 
 
 ############################## PAGING OPERATIONS ##############################
 
+PagingOperationType = TypeVar(
+    "PagingOperationType", bound=Union[PagingOperation, LROPagingOperation]
+)
+
 
-class _PagingOperationBaseSerializer(
-    _OperationBaseSerializer
+class _PagingOperationSerializer(
+    _OperationSerializer[PagingOperationType]
 ):  # pylint: disable=abstract-method
-    def _response_docstring_text_template(
-        self, builder
-    ) -> str:  # pylint: disable=no-self-use, unused-argument
-        if self._cls_docstring_rtype:
-            return "An iterator like instance of either {}" + self._cls_docstring_rtype
-        return "An iterator like instance of {}"
-
-    def cls_type_annotation(self, builder) -> str:
-        interior = super()._response_type_annotation(
-            builder, modify_if_head_as_boolean=False
+    def __init__(
+        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
+    ) -> None:
+        # for pylint reasons need to redefine init
+        # probably because inheritance is going too deep
+        super().__init__(code_model, async_mode, is_python3_file)
+        self.code_model = code_model
+        self.async_mode = async_mode
+        self.is_python3_file = is_python3_file
+        self.parameter_serializer = ParameterSerializer()
+
+    def serialize_path(self, builder: PagingOperationType) -> List[str]:
+        return self.parameter_serializer.serialize_path(
+            builder.parameters.path, self.serializer_name
         )
-        return f"# type: ClsType[{interior}]"
 
-    def decorators(self, builder, async_mode: bool) -> List[str]:
+    def decorators(self, builder: PagingOperationType) -> List[str]:
         """Decorators for the method"""
         retval: List[str] = []
         if self.code_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
-        if builder.abstract:
-            retval.append("@abc.abstractmethod")
         return retval
 
-    def call_next_link_request_builder(self, builder) -> List[str]:
+    def call_next_link_request_builder(self, builder: PagingOperationType) -> List[str]:
         if builder.next_request_builder:
             request_builder = builder.next_request_builder
             template_url = (
@@ -1341,7 +1143,7 @@ class _PagingOperationBaseSerializer(
             builder, request_builder, template_url=template_url, is_next_request=True
         )
 
-    def _prepare_request_callback(self, builder) -> List[str]:
+    def _prepare_request_callback(self, builder: PagingOperationType) -> List[str]:
         retval = ["def prepare_request(next_link=None):"]
         retval.append("    if not next_link:")
         retval.extend(
@@ -1363,17 +1165,13 @@ class _PagingOperationBaseSerializer(
         return retval
 
     @property
-    @abstractmethod
-    def _list_type_returned_to_users(self) -> str:
-        ...
-
-    @staticmethod
-    @abstractmethod
-    def _pager(builder) -> str:
-        ...
+    def _function_def(self) -> str:
+        return "def"
 
-    def _extract_data_callback(self, builder) -> List[str]:
-        retval = [f"{self._def} extract_data(pipeline_response):"]
+    def _extract_data_callback(self, builder: PagingOperationType) -> List[str]:
+        retval = [
+            f"{'async ' if self.async_mode else ''}def extract_data(pipeline_response):"
+        ]
         response = builder.responses[0]
         deserialized = (
             f'self._deserialize("{response.serialization_type}", pipeline_response)'
@@ -1381,7 +1179,7 @@ class _PagingOperationBaseSerializer(
             else "pipeline_response.http_response.json()"
         )
         retval.append(f"    deserialized = {deserialized}")
-        item_name = builder.item_name(self.code_model)
+        item_name = builder.item_name
         list_of_elem = (
             f".{item_name}"
             if self.code_model.options["models_mode"]
@@ -1391,29 +1189,22 @@ class _PagingOperationBaseSerializer(
         retval.append("    if cls:")
         retval.append("        list_of_elem = cls(list_of_elem)")
 
-        next_link_name = builder.next_link_name
-        if not next_link_name:
-            next_link_property = "None"
+        continuation_token_name = builder.continuation_token_name
+        if not continuation_token_name:
+            cont_token_property = "None"
         elif self.code_model.options["models_mode"]:
-            next_link_property = f"deserialized.{next_link_name} or None"
+            cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
-            next_link_property = f'deserialized.get("{next_link_name}", None)'
-        retval.append(
-            f"    return {next_link_property}, {self._list_type_returned_to_users}(list_of_elem)"
-        )
+            cont_token_property = f'deserialized.get("{continuation_token_name}", None)'
+        list_type = "AsyncList" if self.async_mode else "iter"
+        retval.append(f"    return {cont_token_property}, {list_type}(list_of_elem)")
         return retval
 
-    def _get_next_callback(self, builder) -> List[str]:
-        retval = [f"{self._def} get_next(next_link=None):"]
+    def _get_next_callback(self, builder: PagingOperationType) -> List[str]:
+        retval = [f"{'async ' if self.async_mode else ''}def get_next(next_link=None):"]
         retval.append("    request = prepare_request(next_link)")
         retval.append("")
-        retval.append(
-            f"    pipeline_response = {self._call_method}self._client._pipeline.run(  # pylint: disable=protected-access"
-        )
-        retval.append("        request,")
-        retval.append(f"        stream={builder.is_stream_response},")
-        retval.append("        **kwargs")
-        retval.append("    )")
+        retval.extend([f"    {l}" for l in self.make_pipeline_call(builder)])
         retval.append("    response = pipeline_response.http_response")
         retval.append("")
         retval.extend([f"    {line}" for line in self.handle_error_response(builder)])
@@ -1421,7 +1212,7 @@ class _PagingOperationBaseSerializer(
         retval.append("    return pipeline_response")
         return retval
 
-    def set_up_params_for_pager(self, builder) -> List[str]:
+    def set_up_params_for_pager(self, builder: PagingOperationType) -> List[str]:
         retval = []
         retval.extend(self.error_map(builder))
         retval.extend(self._prepare_request_callback(builder))
@@ -1432,100 +1223,41 @@ class _PagingOperationBaseSerializer(
         return retval
 
 
-class _SyncPagingOperationBaseSerializer(
-    _PagingOperationBaseSerializer, _SyncOperationBaseSerializer
-):  # pylint: disable=abstract-method
-    def _response_docstring_type_wrapper(
-        self, builder
-    ) -> List[str]:  # pylint: no-self-use
-        return [f"~{builder.get_pager_path(async_mode=False)}"]
-
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        return ["Iterable"]
-
-    @property
-    def _list_type_returned_to_users(self) -> str:  # pylint: disable=no-self-use
-        return "iter"
-
-    @staticmethod
-    def _pager(builder) -> str:
-        return builder.get_pager(async_mode=False)
-
-
-class SyncPagingOperationGenericSerializer(
-    _SyncPagingOperationBaseSerializer, SyncOperationGenericSerializer
-):
-    pass
-
-
-class SyncPagingOperationPython3Serializer(
-    _SyncPagingOperationBaseSerializer, SyncOperationPython3Serializer
-):
-    pass
-
-
-class AsyncPagingOperationSerializer(
-    _PagingOperationBaseSerializer, AsyncOperationSerializer
-):
-    def _response_docstring_type_wrapper(
-        self, builder
-    ) -> List[str]:  # pylint: no-self-use
-        return [f"~{builder.get_pager_path(async_mode=True)}"]
-
-    @property
-    def _function_definition(self) -> str:
-        return "def"
-
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        return ["AsyncIterable"]
-
-    @property
-    def _list_type_returned_to_users(self) -> str:  # pylint: disable=no-self-use
-        return "AsyncList"
-
-    @staticmethod
-    def _pager(builder) -> str:
-        return builder.get_pager(async_mode=True)
+class PagingOperationSerializer(_PagingOperationSerializer[PagingOperation]):
+    ...
 
 
 ############################## LRO OPERATIONS ##############################
 
+LROOperationType = TypeVar(
+    "LROOperationType", bound=Union[LROOperation, LROPagingOperation]
+)
 
-class _LROOperationBaseSerializer(
-    _OperationBaseSerializer
-):  # pylint: disable=abstract-method
-    def cls_type_annotation(self, builder) -> str:
-        return f"# type: ClsType[{super()._response_type_annotation(builder, modify_if_head_as_boolean=False)}]"
-
-    @abstractmethod
-    def _default_polling_method(self, builder) -> str:
-        ...
-
-    @abstractmethod
-    def _default_no_polling_method(self, builder) -> str:
-        ...
 
-    @abstractmethod
-    def _poller(self, builder) -> str:
-        ...
-
-    @property
-    @abstractmethod
-    def _polling_method_type(self):
-        ...
+class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
+    def __init__(
+        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
+    ) -> None:
+        # for pylint reasons need to redefine init
+        # probably because inheritance is going too deep
+        super().__init__(code_model, async_mode, is_python3_file)
+        self.code_model = code_model
+        self.async_mode = async_mode
+        self.is_python3_file = is_python3_file
+        self.parameter_serializer = ParameterSerializer()
 
-    def param_description(self, builder) -> List[str]:
+    def param_description(self, builder: LROOperationType) -> List[str]:
         retval = super().param_description(builder)
         retval.append(
             ":keyword str continuation_token: A continuation token to restart a poller from a saved state."
         )
         retval.append(
-            f":keyword polling: By default, your polling method will be {self._default_polling_method(builder)}. "
+            f":keyword polling: By default, your polling method will be {builder.get_polling_method(self.async_mode)}. "
             "Pass in False for this operation to not poll, or pass in your own initialized polling object for a"
             " personal polling strategy."
         )
         retval.append(
-            f":paramtype polling: bool or ~azure.core.polling.{self._polling_method_type}"
+            f":paramtype polling: bool or ~{builder.get_base_polling_method_path(self.async_mode)}"
         )
         retval.append(
             ":keyword int polling_interval: Default waiting time between two polls for LRO operations "
@@ -1533,9 +1265,15 @@ class _LROOperationBaseSerializer(
         )
         return retval
 
-    def initial_call(self, builder) -> List[str]:
+    def serialize_path(self, builder: LROOperationType) -> List[str]:
+        return self.parameter_serializer.serialize_path(
+            builder.parameters.path, self.serializer_name
+        )
+
+    def initial_call(self, builder: LROOperationType) -> List[str]:
         retval = [
-            f"polling = kwargs.pop('polling', True)  # type: Union[bool, {self._polling_method_type}]"
+            "polling = kwargs.pop('polling', True)  # type: Union[bool, "
+            f"{builder.get_base_polling_method(self.async_mode)}]"
         ]
         retval.append("lro_delay = kwargs.pop(")
         retval.append("    'polling_interval',")
@@ -1550,7 +1288,7 @@ class _LROOperationBaseSerializer(
         )
         retval.extend(
             [
-                f"        {parameter.serialized_name}={parameter.serialized_name},"
+                f"        {parameter.client_name}={parameter.client_name},"
                 for parameter in builder.parameters.method
             ]
         )
@@ -1562,7 +1300,7 @@ class _LROOperationBaseSerializer(
         retval.append("kwargs.pop('error_map', None)")
         return retval
 
-    def return_lro_poller(self, builder) -> List[str]:
+    def return_lro_poller(self, builder: LROOperationType) -> List[str]:
         retval = []
         lro_options_str = (
             "lro_options={'final-state-via': '"
@@ -1579,40 +1317,46 @@ class _LROOperationBaseSerializer(
         retval.extend(
             [
                 "if polling is True:",
-                f"    polling_method = cast({self._polling_method_type}, {self._default_polling_method(builder)}(",
+                f"    polling_method = cast({builder.get_base_polling_method(self.async_mode)}, "
+                f"{builder.get_polling_method(self.async_mode)}(",
                 "        lro_delay,",
                 f"        {lro_options_str}",
                 f"        {path_format_arguments_str}",
                 "        **kwargs",
-                f"))  # type: {self._polling_method_type}",
+                f"))  # type: {builder.get_base_polling_method(self.async_mode)}",
             ]
         )
         retval.append(
-            f"elif polling is False: polling_method = cast({self._polling_method_type}, "
-            f"{self._default_no_polling_method(builder)}())"
+            f"elif polling is False: polling_method = cast({builder.get_base_polling_method(self.async_mode)}, "
+            f"{builder.get_no_polling_method(self.async_mode)}())"
         )
         retval.append("else: polling_method = polling")
         retval.append("if cont_token:")
-        retval.append(f"    return {self._poller(builder)}.from_continuation_token(")
+        retval.append(
+            f"    return {builder.get_poller(self.async_mode)}.from_continuation_token("
+        )
         retval.append("        polling_method=polling_method,")
         retval.append("        continuation_token=cont_token,")
         retval.append("        client=self._client,")
         retval.append("        deserialization_callback=get_long_running_output")
         retval.append("    )")
         retval.append(
-            f"return {self._poller(builder)}"
+            f"return {builder.get_poller(self.async_mode)}"
             "(self._client, raw_result, get_long_running_output, polling_method)"
         )
         return retval
 
-    def get_long_running_output(self, builder) -> List[str]:
-        retval = ["def get_long_running_output(pipeline_response):"]
+    def get_long_running_output(self, builder: LROOperationType) -> List[str]:
+        pylint_disable = ""
+        if not builder.lro_response:
+            pylint_disable = "  # pylint: disable=inconsistent-return-statements"
+        retval = [f"def get_long_running_output(pipeline_response):{pylint_disable}"]
         if builder.lro_response:
-            if builder.lro_response.has_headers:
+            if builder.lro_response.headers:
                 retval.append("    response_headers = {}")
             if (
                 not self.code_model.options["models_mode"]
-                or builder.lro_response.has_headers
+                or builder.lro_response.headers
             ):
                 retval.append("    response = pipeline_response.http_response")
             retval.extend(
@@ -1627,268 +1371,75 @@ class _LROOperationBaseSerializer(
         retval.append(
             "        return cls(pipeline_response, {}, {})".format(
                 "deserialized"
-                if builder.lro_response and builder.lro_response.has_body
+                if builder.lro_response and builder.lro_response.type
                 else "None",
                 "response_headers"
-                if builder.lro_response and builder.lro_response.has_headers
+                if builder.lro_response and builder.lro_response.headers
                 else "{}",
             )
         )
-        if builder.lro_response and builder.lro_response.has_body:
+        if builder.lro_response and builder.lro_response.type:
             retval.append("    return deserialized")
         return retval
 
 
-class _SyncLROOperationBaseSerializer(
-    _LROOperationBaseSerializer, _SyncOperationBaseSerializer
-):  # pylint: disable=abstract-method
-    def _response_docstring_text_template(
-        self, builder
-    ) -> str:  # pylint: disable=no-self-use
-        lro_section = f"An instance of {builder.get_poller(async_mode=False)} "
-        if self._cls_docstring_rtype:
-            return lro_section + "that returns either {}" + self._cls_docstring_rtype
-        return lro_section + "that returns {}"
-
-    def _response_docstring_type_wrapper(
-        self, builder
-    ) -> List[str]:  # pylint: no-self-use
-        return [f"~{builder.get_poller_path(async_mode=False)}"]
-
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        return [builder.get_poller(async_mode=False)]
-
-    def _default_polling_method(self, builder) -> str:
-        return builder.get_default_polling_method(
-            async_mode=False, azure_arm=self.code_model.options["azure_arm"]
-        )
-
-    def _default_no_polling_method(self, builder) -> str:
-        return builder.get_default_no_polling_method(async_mode=False)
-
-    @property
-    def _polling_method_type(self):
-        return "PollingMethod"
-
-    def _poller(self, builder) -> str:
-        return builder.get_poller(async_mode=False)
-
-
-class SyncLROOperationGenericSerializer(
-    _SyncLROOperationBaseSerializer, SyncOperationGenericSerializer
-):
-    pass
-
-
-class SyncLROOperationPython3Serializer(
-    _SyncLROOperationBaseSerializer, SyncOperationPython3Serializer
-):
-    pass
-
-
-class AsyncLROOperationSerializer(
-    _LROOperationBaseSerializer, AsyncOperationSerializer
-):
-    def _response_docstring_text_template(
-        self, builder
-    ) -> str:  # pylint: disable=no-self-use
-        lro_section = f"An instance of {builder.get_poller(async_mode=True)} "
-        if self._cls_docstring_rtype:
-            return lro_section + "that returns either {}" + self._cls_docstring_rtype
-        return lro_section + "that returns {}"
+class LROOperationSerializer(_LROOperationSerializer[LROOperation]):
+    ...
 
-    def _response_docstring_type_wrapper(
-        self, builder
-    ) -> List[str]:  # pylint: no-self-use
-        return [f"~{builder.get_poller_path(async_mode=True)}"]
 
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        return [builder.get_poller(async_mode=True)]
-
-    def _default_polling_method(self, builder) -> str:
-        return builder.get_default_polling_method(
-            async_mode=True, azure_arm=self.code_model.options["azure_arm"]
-        )
+############################## LRO PAGING OPERATIONS ##############################
 
-    def _default_no_polling_method(self, builder) -> str:
-        return builder.get_default_no_polling_method(async_mode=True)
 
+class LROPagingOperationSerializer(
+    _LROOperationSerializer[LROPagingOperation],
+    _PagingOperationSerializer[LROPagingOperation],
+):  # pylint: disable=abstract-method
     @property
-    def _polling_method_type(self):
-        return "AsyncPollingMethod"
-
-    def _poller(self, builder) -> str:
-        return builder.get_poller(async_mode=True)
-
-
-############################## LRO PAGING OPERATIONS ##############################
+    def _call_method(self) -> str:
+        return "await " if self.async_mode else ""
 
+    @property
+    def _function_def(self) -> str:
+        return "async def" if self.async_mode else "def"
 
-class _LROPagingOperationBaseSerializer(
-    _LROOperationBaseSerializer, _PagingOperationBaseSerializer
-):  # pylint: disable=abstract-method
-    def get_long_running_output(self, builder) -> List[str]:
+    def get_long_running_output(self, builder: LROPagingOperation) -> List[str]:
         retval = ["def get_long_running_output(pipeline_response):"]
-        retval.append(f"    {self._def} internal_get_next(next_link=None):")
+        retval.append(f"    {self._function_def} internal_get_next(next_link=None):")
         retval.append("        if next_link is None:")
         retval.append("            return pipeline_response")
         retval.append(f"        return {self._call_method}get_next(next_link)")
         retval.append("")
-        retval.append(f"    return {self._pager(builder)}(")
+        retval.append(f"    return {builder.get_pager(self.async_mode)}(")
         retval.append("        internal_get_next, extract_data")
         retval.append("    )")
         return retval
 
-    def decorators(self, builder, async_mode: bool) -> List[str]:
+    def decorators(self, builder: LROPagingOperation) -> List[str]:  # type: ignore
         """Decorators for the method"""
-        return _LROOperationBaseSerializer.decorators(self, builder, async_mode)
-
-
-class _SyncLROPagingOperationBaseSerializer(  # pylint: disable=abstract-method
-    _SyncLROOperationBaseSerializer,
-    _SyncPagingOperationBaseSerializer,
-    _LROPagingOperationBaseSerializer,
-):
-    def _response_docstring_type_wrapper(self, builder) -> List[str]:
-        return _SyncLROOperationBaseSerializer._response_docstring_type_wrapper(
-            self, builder
-        ) + _SyncPagingOperationBaseSerializer._response_docstring_type_wrapper(
-            self, builder
-        )
-
-    def _response_type_annotation_wrapper(self, builder) -> List[str]:
-        return _SyncLROOperationBaseSerializer._response_type_annotation_wrapper(
-            self, builder
-        ) + [builder.get_pager(async_mode=False)]
-
-    def _response_docstring_text_template(self, builder) -> str:
-        lro_doc = _SyncLROOperationBaseSerializer._response_docstring_text_template(
-            self, builder
-        )
-        paging_doc = (
-            _SyncPagingOperationBaseSerializer._response_docstring_text_template(
-                self, builder
-            )
-        )
-        paging_doc = paging_doc.replace(paging_doc[0], paging_doc[0].lower(), 1)
-        return (
-            lro_doc.format(paging_doc)
-            .replace(self._cls_docstring_rtype, "", 1)
-            .replace("either ", "", 1)
-        )
-
-    def cls_type_annotation(self, builder) -> str:
-        return f"# type: ClsType[{self._response_type_annotation(builder, modify_if_head_as_boolean=False)}]"
-
-
-class SyncLROPagingOperationGenericSerializer(
-    _SyncLROPagingOperationBaseSerializer, SyncOperationGenericSerializer
-):
-    pass
-
-
-class SyncLROPagingOperationPython3Serializer(
-    _SyncLROPagingOperationBaseSerializer, SyncOperationPython3Serializer
-):
-    pass
-
-
-class AsyncLROPagingOperationSerializer(
-    _LROPagingOperationBaseSerializer,
-    AsyncLROOperationSerializer,
-    AsyncPagingOperationSerializer,
-):
-    @property
-    def _function_definition(self) -> str:
-        return "async def"
-
-    def _response_docstring_type_wrapper(self, builder) -> List[str]:
-        return AsyncLROOperationSerializer._response_docstring_type_wrapper(
-            self, builder
-        ) + AsyncPagingOperationSerializer._response_docstring_type_wrapper(
-            self, builder
-        )
-
-    def _response_type_annotation_wrapper(
-        self, builder: LROPagingOperation
-    ) -> List[str]:
-        return AsyncLROOperationSerializer._response_type_annotation_wrapper(
-            self, builder
-        ) + [builder.get_pager(async_mode=True)]
-
-    def _response_docstring_text_template(self, builder) -> str:
-        lro_doc = AsyncLROOperationSerializer._response_docstring_text_template(
-            self, builder
-        )
-        paging_doc = AsyncPagingOperationSerializer._response_docstring_text_template(
-            self, builder
-        )
-        paging_doc = paging_doc.replace(paging_doc[0], paging_doc[0].lower(), 1)
-        return (
-            lro_doc.format(paging_doc)
-            .replace(self._cls_docstring_rtype, "", 1)
-            .replace("either ", "", 1)
-        )
+        return _LROOperationSerializer.decorators(self, builder)  # type: ignore
 
 
 def get_operation_serializer(
-    builder,
+    builder: Operation,
     code_model,
     async_mode: bool,
     is_python3_file: bool,
-) -> _OperationBaseSerializer:
-    retcls = _OperationBaseSerializer
-    if isinstance(builder, LROPagingOperation):
-        retcls = (
-            AsyncLROPagingOperationSerializer
-            if async_mode
-            else (
-                SyncLROPagingOperationPython3Serializer
-                if is_python3_file
-                else SyncLROPagingOperationGenericSerializer
-            )
-        )
-        return retcls(code_model)
-    if isinstance(builder, LROOperation):
-        retcls = (
-            AsyncLROOperationSerializer
-            if async_mode
-            else (
-                SyncLROOperationPython3Serializer
-                if is_python3_file
-                else SyncLROOperationGenericSerializer
-            )
-        )
-        return retcls(code_model)
-    if isinstance(builder, PagingOperation):
-        retcls = (
-            AsyncPagingOperationSerializer
-            if async_mode
-            else (
-                SyncPagingOperationPython3Serializer
-                if is_python3_file
-                else SyncPagingOperationGenericSerializer
-            )
-        )
-        return retcls(code_model)
-    retcls = (
-        AsyncOperationSerializer
-        if async_mode
-        else (
-            SyncOperationPython3Serializer
-            if is_python3_file
-            else SyncOperationGenericSerializer
-        )
-    )
-    return retcls(code_model)
-
-
-def get_request_builder_serializer(
-    code_model, is_python3_file: bool
-) -> _RequestBuilderBaseSerializer:
-    retcls = (
-        RequestBuilderPython3Serializer
-        if is_python3_file
-        else RequestBuilderGenericSerializer
-    )
-    return retcls(code_model)
+) -> Union[
+    OperationSerializer,
+    PagingOperationSerializer,
+    LROOperationSerializer,
+    LROPagingOperationSerializer,
+]:
+    retcls: Union[
+        Type[OperationSerializer],
+        Type[PagingOperationSerializer],
+        Type[LROOperationSerializer],
+        Type[LROPagingOperationSerializer],
+    ] = OperationSerializer
+    if builder.operation_type == "lropaging":
+        retcls = LROPagingOperationSerializer
+    elif builder.operation_type == "lro":
+        retcls = LROOperationSerializer
+    elif builder.operation_type == "paging":
+        retcls = PagingOperationSerializer
+    return retcls(code_model, async_mode, is_python3_file)