@typespec/http-client-python 0.33.0 → 0.34.1

package/generator/component-detection-pip-report.json

@@ -4,12 +4,12 @@
   "install": [
     {
       "download_info": {
-        "url": "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl",
+        "url": "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl",
         "archive_info": {
           "hashes": {
-            "sha256": "a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb"
+            "sha256": "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3"
           },
-          "hash": "sha256=a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb"
+          "hash": "sha256=29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3"
         }
       },
       "is_direct": false,
@@ -18,12 +18,12 @@
       "metadata": {
         "metadata_version": "2.4",
         "name": "setuptools",
-        "version": "82.0.1",
+        "version": "83.0.0",
         "dynamic": [
           "license-file"
         ],
         "summary": "Most extensible Python build backend with support for C/C++ extension modules",
-        "description": ".. |pypi-version| image:: https://img.shields.io/pypi/v/setuptools.svg\n   :target: https://pypi.org/project/setuptools\n\n.. |py-version| image:: https://img.shields.io/pypi/pyversions/setuptools.svg\n\n.. |test-badge| image:: https://github.com/pypa/setuptools/actions/workflows/main.yml/badge.svg\n   :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22\n   :alt: tests\n\n.. |ruff-badge| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json\n   :target: https://github.com/astral-sh/ruff\n   :alt: Ruff\n\n.. |docs-badge| image:: https://img.shields.io/readthedocs/setuptools/latest.svg\n   :target: https://setuptools.pypa.io\n\n.. |skeleton-badge| image:: https://img.shields.io/badge/skeleton-2025-informational\n   :target: https://blog.jaraco.com/skeleton\n\n.. |codecov-badge| image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white\n   :target: https://codecov.io/gh/pypa/setuptools\n\n.. |tidelift-badge| image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat\n   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme\n\n.. |discord-badge| image:: https://img.shields.io/discord/803025117553754132\n   :target: https://discord.com/channels/803025117553754132/815945031150993468\n   :alt: Discord\n\n|pypi-version| |py-version| |test-badge| |ruff-badge| |docs-badge| |skeleton-badge| |codecov-badge| |discord-badge|\n\nSee the `Quickstart <https://setuptools.pypa.io/en/latest/userguide/quickstart.html>`_\nand the `User's Guide <https://setuptools.pypa.io/en/latest/userguide/>`_ for\ninstructions on how to use Setuptools.\n\nQuestions and comments should be directed to `GitHub Discussions\n<https://github.com/pypa/setuptools/discussions>`_.\nBug reports and especially tested patches may be\nsubmitted directly to the `bug tracker\n<https://github.com/pypa/setuptools/issues>`_.\n\n\nCode of Conduct\n===============\n\nEveryone interacting in the setuptools project's codebases, issue trackers,\nchat rooms, and fora is expected to follow the\n`PSF Code of Conduct <https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md>`_.\n\n\nFor Enterprise\n==============\n\nAvailable as part of the Tidelift Subscription.\n\nSetuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.\n\n`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_.\n",
+        "description": ".. |pypi-version| image:: https://img.shields.io/pypi/v/setuptools.svg\n   :target: https://pypi.org/project/setuptools\n\n.. |py-version| image:: https://img.shields.io/pypi/pyversions/setuptools.svg\n\n.. |test-badge| image:: https://github.com/pypa/setuptools/actions/workflows/main.yml/badge.svg\n   :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22\n   :alt: tests\n\n.. |ruff-badge| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json\n   :target: https://github.com/astral-sh/ruff\n   :alt: Ruff\n\n.. |docs-badge| image:: https://img.shields.io/readthedocs/setuptools/latest.svg\n   :target: https://setuptools.pypa.io\n\n.. |skeleton-badge| image:: https://img.shields.io/badge/skeleton-2026-informational\n   :target: https://blog.jaraco.com/skeleton\n\n.. |codecov-badge| image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white\n   :target: https://codecov.io/gh/pypa/setuptools\n\n.. |tidelift-badge| image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat\n   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme\n\n.. |discord-badge| image:: https://img.shields.io/discord/803025117553754132\n   :target: https://discord.com/channels/803025117553754132/815945031150993468\n   :alt: Discord\n\n|pypi-version| |py-version| |test-badge| |ruff-badge| |docs-badge| |skeleton-badge| |codecov-badge| |discord-badge|\n\nSee the `Quickstart <https://setuptools.pypa.io/en/latest/userguide/quickstart.html>`_\nand the `User's Guide <https://setuptools.pypa.io/en/latest/userguide/>`_ for\ninstructions on how to use Setuptools.\n\nQuestions and comments should be directed to `GitHub Discussions\n<https://github.com/pypa/setuptools/discussions>`_.\nBug reports and especially tested patches may be\nsubmitted directly to the `bug tracker\n<https://github.com/pypa/setuptools/issues>`_.\n\n\nCode of Conduct\n===============\n\nEveryone interacting in the setuptools project's codebases, issue trackers,\nchat rooms, and fora is expected to follow the\n`PSF Code of Conduct <https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md>`_.\n\n\nFor Enterprise\n==============\n\nAvailable as part of the Tidelift Subscription.\n\nSetuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.\n\n`Learn more <https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=referral&utm_campaign=github>`_.\n",
         "description_content_type": "text/x-rst",
         "keywords": [
           "CPAN",
@@ -90,17 +90,17 @@
           "wheel>=0.43.0; extra == \"core\"",
           "jaraco.functools>=4; extra == \"core\"",
           "more_itertools; extra == \"core\"",
-          "pytest-checkdocs>=2.4; extra == \"check\"",
+          "pytest-checkdocs>=2.14; extra == \"check\"",
           "pytest-ruff>=0.2.1; sys_platform != \"cygwin\" and extra == \"check\"",
           "ruff>=0.13.0; sys_platform != \"cygwin\" and extra == \"check\"",
           "pytest-cov; extra == \"cover\"",
-          "pytest-enabler>=2.2; extra == \"enabler\"",
-          "pytest-mypy; extra == \"type\"",
+          "pytest-enabler>=3.4; extra == \"enabler\"",
+          "pytest-mypy>=1.0.1; platform_python_implementation != \"PyPy\" and extra == \"type\"",
           "mypy==1.18.*; extra == \"type\"",
           "importlib_metadata>=7.0.2; python_version < \"3.10\" and extra == \"type\"",
           "jaraco.develop>=7.21; sys_platform != \"cygwin\" and extra == \"type\""
         ],
-        "requires_python": ">=3.9",
+        "requires_python": ">=3.10",
         "project_url": [
           "Source, https://github.com/pypa/setuptools",
           "Documentation, https://setuptools.pypa.io/",

package/generator/pygen/__init__.py

@@ -168,10 +168,10 @@ class OptionsDict(MutableMapping):
         if key == "models-mode" and value == "none":
             value = False  # switch to falsy value for easier code writing
 
-        if key == "models-mode" and value not in ["msrest", "dpg", False]:
+        if key == "models-mode" and value not in ["msrest", "dpg", "typeddict", False]:
             raise ValueError(
-                "--models-mode can only be 'msrest', 'dpg' or 'none'. "
-                "Pass in 'msrest' if you want msrest models, or "
+                "--models-mode can only be 'msrest', 'dpg', 'typeddict', or 'none'. "
+                "Pass in 'msrest' if you want msrest models, 'typeddict' for TypedDict models, or "
                 "'none' if you don't want any."
             )
         if key == "package-mode":

package/generator/pygen/codegen/models/__init__.py

@@ -9,7 +9,7 @@ from .base import BaseModel
 from .base_builder import BaseBuilder, ParameterListType
 from .code_model import CodeModel
 from .client import Client
-from .model_type import ModelType, JSONModelType, DPGModelType, MsrestModelType
+from .model_type import ModelType, JSONModelType, DPGModelType, MsrestModelType, TypedDictModelType
 from .dictionary_type import DictionaryType
 from .list_type import ListType
 from .combined_type import CombinedType
@@ -167,7 +167,9 @@ def build_type(yaml_data: dict[str, Any], code_model: CodeModel) -> BaseType:
     response: Optional[BaseType] = None
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
-        if yaml_data["base"] == "json" or not code_model.options["models-mode"]:
+        if yaml_data["base"] == "typeddict":
+            model_type = TypedDictModelType  # type: ignore
+        elif yaml_data["base"] == "json" or not code_model.options["models-mode"]:
             model_type = JSONModelType
         elif yaml_data["base"] == "dpg":
             model_type = DPGModelType  # type: ignore

package/generator/pygen/codegen/models/code_model.py

@@ -152,16 +152,28 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             return result
         return f"{result}{module_name}" if result.endswith(".") else f"{result}.{module_name}"
 
-    def get_unique_models_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
+    def _get_unique_import_alias(self, serialize_namespace: str, imported_namespace: str, module_name: str) -> str:
         if not self.has_subnamespace:
-            return "_models"
+            return f"_{module_name}"
         relative_path = self.get_relative_import_path(
             serialize_namespace, self.get_imported_namespace_for_model(imported_namespace)
         )
         dot_num = max(relative_path.count(".") - 1, 0)
-        parts = [""] + ([p for p in relative_path.split(".") if p] or ["models"])
+        path_parts = [p for p in relative_path.split(".") if p]
+        # For "models", keep existing format: _<path_parts><dot_num> (e.g. _models1, _firstnamespace_models2)
+        # For other modules like "types", prefix with module name: _types_<path_parts><dot_num>
+        if module_name == "models":
+            parts = [""] + (path_parts or [module_name])
+        else:
+            parts = [f"_{module_name}"] + (path_parts or [])
         return "_".join(parts) + (str(dot_num) if dot_num > 0 else "")
 
+    def get_unique_models_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
+        return self._get_unique_import_alias(serialize_namespace, imported_namespace, "models")
+
+    def get_unique_types_alias(self, serialize_namespace: str, imported_namespace: str) -> str:
+        return self._get_unique_import_alias(serialize_namespace, imported_namespace, "types")
+
     @property
     def client_namespace_types(self) -> dict[str, ClientNamespaceType]:
         if not self._client_namespace_types:
@@ -174,6 +186,14 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
                 if model.client_namespace not in self._client_namespace_types:
                     self._client_namespace_types[model.client_namespace] = ClientNamespaceType()
                 self._client_namespace_types[model.client_namespace].models.append(model)
+            # TypedDict copies (base="typeddict") are excluded from model_types to keep
+            # them out of _models.py, but they need to be in the namespace model list
+            # so the TypesSerializer can render them in types.py.
+            for t in self.types_map.values():
+                if isinstance(t, ModelType) and t.base == "typeddict" and t.usage != UsageFlags.Default.value:
+                    if t.client_namespace not in self._client_namespace_types:
+                        self._client_namespace_types[t.client_namespace] = ClientNamespaceType()
+                    self._client_namespace_types[t.client_namespace].models.append(t)
             for enum in self.enums:
                 if enum.client_namespace not in self._client_namespace_types:
                     self._client_namespace_types[enum.client_namespace] = ClientNamespaceType()
@@ -339,7 +359,9 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         """All of the model types in this class"""
         if not self._model_types:
             self._model_types = [
-                t for t in self.types_map.values() if isinstance(t, ModelType) and t.usage != UsageFlags.Default.value
+                t
+                for t in self.types_map.values()
+                if isinstance(t, ModelType) and t.usage != UsageFlags.Default.value and t.base != "typeddict"
             ]
         return self._model_types
 
@@ -349,7 +371,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
 
     @staticmethod
     def get_public_model_types(models: list[ModelType]) -> list[ModelType]:
-        return [m for m in models if not m.internal and not m.base == "json"]
+        return [m for m in models if not m.internal and not m.base == "json" and not m.is_typed_dict_only]
 
     @property
     def public_model_types(self) -> list[ModelType]:

package/generator/pygen/codegen/models/combined_type.py

@@ -66,7 +66,7 @@ class CombinedType(BaseType):
 
     def type_annotation(self, **kwargs: Any) -> str:
         if self.name:
-            return f'"_types.{self.name}"'
+            return f'"_unions.{self.name}"'
         return self.type_definition(**kwargs)
 
     def type_definition(self, **kwargs: Any) -> str:
@@ -116,10 +116,10 @@ class CombinedType(BaseType):
         file_import = FileImport(self.code_model)
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         serialize_namespace_type = kwargs.get("serialize_namespace_type")
-        if self.name and serialize_namespace_type != NamespaceType.TYPES_FILE:
+        if self.name and serialize_namespace_type != NamespaceType.UNIONS_FILE:
             file_import.add_submodule_import(
                 self.code_model.get_relative_import_path(serialize_namespace),
-                "_types",
+                "_unions",
                 ImportType.LOCAL,
                 TypingSection.TYPING,
             )

package/generator/pygen/codegen/models/enum_type.py

@@ -167,6 +167,10 @@ class EnumType(BaseType):
         enum_description = f"Known values are: {possible_values_str}."
         return enum_description
 
+    @property
+    def is_typeddict_mode(self) -> bool:
+        return self.code_model.options["models-mode"] == "typeddict"
+
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation
 
@@ -174,9 +178,20 @@ class EnumType(BaseType):
         :rtype: str
         """
         if self.code_model.options["models-mode"]:
+            if self.is_typeddict_mode:
+                # In typeddict mode, enums are Literal aliases defined in types.py
+                serialize_namespace_type = kwargs.get("serialize_namespace_type")
+                if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                    # Same file — just the name, no module prefix
+                    return self.name
+                # From operation/client files, use types.EnumName (matching model pattern)
+                return f"types.{self.name}"
 
             module_name = ""
-            if kwargs.get("need_model_alias", True):
+            serialize_namespace_type = kwargs.get("serialize_namespace_type")
+            if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                pass  # no module prefix for types.py
+            elif kwargs.get("need_model_alias", True):
                 serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
                 model_alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
                 module_name = f"{model_alias}."
@@ -240,31 +255,66 @@ class EnumType(BaseType):
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         if self.code_model.options["models-mode"]:
-            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.REGULAR)
+            if self.is_typeddict_mode:
+                # In typeddict mode, enums are Literal aliases in types.py — no Union needed
+                serialize_namespace_type = kwargs.get("serialize_namespace_type")
+                if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                    # Same file — no import needed for same-namespace enums
+                    serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+                    if self.client_namespace != serialize_namespace:
+                        # Cross-namespace: import from sibling types module
+                        relative_path = self.code_model.get_relative_import_path(
+                            serialize_namespace, self.client_namespace
+                        )
+                        file_import.add_submodule_import(
+                            f"{relative_path}types" if relative_path != "." else ".types",
+                            self.name,
+                            ImportType.LOCAL,
+                            typing_section=TypingSection.REGULAR,
+                        )
+                elif serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
+                    # Import types module directly (matching model pattern)
+                    serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+                    relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
+                    file_import.add_submodule_import(
+                        relative_path,
+                        "types",
+                        ImportType.LOCAL,
+                    )
+            else:
+                file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.REGULAR)
 
-            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
-            relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
-            alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
-            serialize_namespace_type = kwargs.get("serialize_namespace_type")
-            called_by_property = kwargs.get("called_by_property", False)
-            if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
-                file_import.add_submodule_import(
-                    relative_path,
-                    "models",
-                    ImportType.LOCAL,
-                    alias=alias,
-                    typing_section=TypingSection.REGULAR,
-                )
-            elif serialize_namespace_type == NamespaceType.TYPES_FILE or (
-                serialize_namespace_type == NamespaceType.MODEL and called_by_property
-            ):
-                file_import.add_submodule_import(
-                    relative_path,
-                    "models",
-                    ImportType.LOCAL,
-                    alias=alias,
-                    typing_section=TypingSection.TYPING,
-                )
+                serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+                relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
+                alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
+                serialize_namespace_type = kwargs.get("serialize_namespace_type")
+                called_by_property = kwargs.get("called_by_property", False)
+                if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
+                    file_import.add_submodule_import(
+                        relative_path,
+                        "models",
+                        ImportType.LOCAL,
+                        alias=alias,
+                        typing_section=TypingSection.REGULAR,
+                    )
+                elif serialize_namespace_type == NamespaceType.TYPES_FILE:
+                    # Import enum name directly to avoid dotted forward refs in TypedDict annotations
+                    file_import.add_submodule_import(
+                        f"{relative_path}models" if relative_path != "." else ".models",
+                        self.name,
+                        ImportType.LOCAL,
+                        typing_section=TypingSection.TYPING,
+                    )
+                elif serialize_namespace_type == NamespaceType.UNIONS_FILE or (
+                    serialize_namespace_type == NamespaceType.MODEL and called_by_property
+                ):
+                    file_import.add_submodule_import(
+                        relative_path,
+                        "models",
+                        ImportType.LOCAL,
+                        alias=alias,
+                        typing_section=TypingSection.TYPING,
+                    )
 
         file_import.merge(self.value_type.imports(**kwargs))
         return file_import

package/generator/pygen/codegen/models/list_type.py

@@ -6,6 +6,7 @@
 from typing import Any, Optional, Union, TYPE_CHECKING
 from .base import BaseType
 from .imports import FileImport
+from .utils import NamespaceType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
@@ -41,12 +42,17 @@ class ListType(BaseType):
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.type_annotation(**kwargs)
 
-        # if there is a function/property named `list` we have to make sure there's no conflict with the built-in `list`
+        # if there is a function named `list` we have to make sure there's no conflict with the built-in `list`
+        # in operation files. The operation_groups_serializer defines `List = list` alias for this case.
+        serialize_namespace_type = kwargs.get("serialize_namespace_type")
         is_operation_file = kwargs.get("is_operation_file", False)
-        use_list_import = (self.code_model.has_operation_named_list and is_operation_file) or (
-            self.code_model.has_property_named_list and not is_operation_file
+        in_operation_context = (
+            serialize_namespace_type in (NamespaceType.OPERATION, NamespaceType.CLIENT) or is_operation_file
         )
-        list_type = "List" if use_list_import else "list"
+        if in_operation_context and self.code_model.has_operation_named_list:
+            list_type = "List"
+        else:
+            list_type = "list"
         return f"{list_type}[{self.element_type.type_annotation(**kwargs)}]"
 
     def description(self, *, is_operation_file: bool) -> str:

package/generator/pygen/codegen/models/model_type.py

@@ -77,11 +77,23 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes, too-
         self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
         self.usage: int = self.yaml_data.get("usage", UsageFlags.Input.value | UsageFlags.Output.value)
         self.client_namespace: str = self.yaml_data.get("clientNamespace", code_model.namespace)
+        self.is_typed_dict_only: bool = (
+            self.yaml_data.get("typedDictOnly", False) or code_model.options["models-mode"] == "typeddict"
+        )
 
     @property
     def is_usage_output(self) -> bool:
         return bool(self.usage & UsageFlags.Output.value)
 
+    @property
+    def is_usage_input(self) -> bool:
+        return bool(self.usage & UsageFlags.Input.value)
+
+    @property
+    def is_used_in_operations_via_types(self) -> bool:
+        """Whether this model would be imported from types.py (not models) in operations."""
+        return False
+
     @property
     def flattened_property(self) -> Optional[Property]:
         try:
@@ -275,12 +287,20 @@ class GeneratedModelType(ModelType):
     def type_annotation(self, **kwargs: Any) -> str:
         is_operation_file = kwargs.pop("is_operation_file", False)
         skip_quote = kwargs.get("skip_quote", False)
+        serialize_namespace_type = kwargs.get("serialize_namespace_type")
         module_name = ""
-        if kwargs.get("need_model_alias", True):
+        # In types.py, use bare name to avoid pyright "variable in type expression" errors
+        if serialize_namespace_type == NamespaceType.TYPES_FILE:
+            pass  # no module prefix, no internal file prefix
+        elif kwargs.get("need_model_alias", True):
             serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             model_alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
             module_name = f"{model_alias}."
-        file_name = f"{self.code_model.models_filename}." if self.internal else ""
+        file_name = (
+            f"{self.code_model.models_filename}."
+            if self.internal and serialize_namespace_type != NamespaceType.TYPES_FILE
+            else ""
+        )
         retval = module_name + file_name + self.name
         return retval if is_operation_file or skip_quote else f'"{retval}"'
 
@@ -305,7 +325,7 @@ class GeneratedModelType(ModelType):
         alias = self.code_model.get_unique_models_alias(serialize_namespace, self.client_namespace)
         serialize_namespace_type = kwargs.get("serialize_namespace_type")
         called_by_property = kwargs.get("called_by_property", False)
-        # add import for models in operations or _types file
+        # add import for models in operations, types, or unions file
         if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
             file_import.add_submodule_import(
                 relative_path,
@@ -320,7 +340,33 @@ class GeneratedModelType(ModelType):
                     ImportType.LOCAL,
                     alias="_Model",
                 )
-        elif serialize_namespace_type == NamespaceType.TYPES_FILE or (
+        elif serialize_namespace_type == NamespaceType.TYPES_FILE:
+            # Don't import models that will be defined in this namespace's types.py —
+            # either as TypedDict classes (non-discriminated) or as Union aliases (discriminated bases).
+            # Only same-namespace non-json models are in the same types.py file.
+            same_namespace = relative_path == "."
+            will_be_in_types_file = self.base != "json" and same_namespace
+            if not will_be_in_types_file:
+                if same_namespace:
+                    # json models from same namespace — import from .models (or .models._models for internal)
+                    import_path = f".models.{self.code_model.models_filename}" if self.internal else ".models"
+                    file_import.add_submodule_import(
+                        import_path,
+                        self.name,
+                        ImportType.LOCAL,
+                        typing_section=TypingSection.TYPING,
+                    )
+                else:
+                    # Cross-namespace model — import from sibling namespace's types module
+                    file_import.add_submodule_import(
+                        self.code_model.get_relative_import_path(
+                            serialize_namespace, self.client_namespace, module_name="types"
+                        ),
+                        self.name,
+                        ImportType.LOCAL,
+                        typing_section=TypingSection.TYPING,
+                    )
+        elif serialize_namespace_type == NamespaceType.UNIONS_FILE or (
             serialize_namespace_type == NamespaceType.MODEL and called_by_property
         ):
             file_import.add_submodule_import(
@@ -352,6 +398,33 @@ class MsrestModelType(GeneratedModelType):
 class DPGModelType(GeneratedModelType):
     base = "dpg"
 
+    @property
+    def is_used_in_operations_via_types(self) -> bool:
+        return self.is_typed_dict_only
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.is_typed_dict_only:
+            is_operation_file = kwargs.pop("is_operation_file", False)
+            skip_quote = kwargs.get("skip_quote", False)
+            serialize_namespace_type = kwargs.get("serialize_namespace_type")
+            # Within types.py, use bare name (no module prefix)
+            if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                retval = self.name
+            else:
+                serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+                types_alias = self.code_model.get_unique_types_alias(serialize_namespace, self.client_namespace)
+                retval = f"{types_alias}.{self.name}"
+            return retval if is_operation_file or skip_quote else f'"{retval}"'
+        return super().type_annotation(**kwargs)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        if self.is_typed_dict_only:
+            client_namespace = self.client_namespace
+            if self.code_model.options.get("generation-subdir"):
+                client_namespace += f".{self.code_model.options['generation-subdir']}"
+            return f"~{client_namespace}.types.{self.name}"
+        return super().docstring_type(**kwargs)
+
     def serialization_type(self, **kwargs: Any) -> str:
         return (
             self.type_annotation(skip_quote=True, **kwargs)
@@ -364,7 +437,79 @@ class DPGModelType(GeneratedModelType):
         return "isinstance({}, " + f"_models.{self.name})"
 
     def imports(self, **kwargs: Any) -> FileImport:
+        if self.is_typed_dict_only:
+            file_import = FileImport(self.code_model)
+            serialize_namespace_type = kwargs.get("serialize_namespace_type")
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+            relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
+            alias = self.code_model.get_unique_types_alias(serialize_namespace, self.client_namespace)
+            same_namespace = relative_path == "."
+            if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
+                file_import.add_submodule_import(
+                    relative_path,
+                    "types",
+                    ImportType.LOCAL,
+                    alias=alias,
+                )
+            elif serialize_namespace_type == NamespaceType.TYPES_FILE and same_namespace:
+                pass  # model is defined in this types.py — no import needed
+            elif serialize_namespace_type in [NamespaceType.TYPES_FILE, NamespaceType.UNIONS_FILE] or (
+                serialize_namespace_type == NamespaceType.MODEL and kwargs.get("called_by_property", False)
+            ):
+                file_import.add_submodule_import(
+                    relative_path,
+                    "types",
+                    ImportType.LOCAL,
+                    alias=alias,
+                    typing_section=TypingSection.TYPING,
+                )
+            return file_import
         file_import = super().imports(**kwargs)
         if self.flattened_property:
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
         return file_import
+
+
+class TypedDictModelType(DPGModelType):
+    base = "typeddict"
+
+    @property
+    def is_used_in_operations_via_types(self) -> bool:
+        return True
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        is_operation_file = kwargs.pop("is_operation_file", False)
+        skip_quote = kwargs.get("skip_quote", False)
+        serialize_namespace_type = kwargs.get("serialize_namespace_type")
+        if serialize_namespace_type == NamespaceType.TYPES_FILE:
+            retval = self.name
+        else:
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+            types_alias = self.code_model.get_unique_types_alias(serialize_namespace, self.client_namespace)
+            retval = f"{types_alias}.{self.name}"
+        return retval if is_operation_file or skip_quote else f'"{retval}"'
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        client_namespace = self.client_namespace
+        if self.code_model.options.get("generation-subdir"):
+            client_namespace += f".{self.code_model.options['generation-subdir']}"
+        return f"~{client_namespace}.types.{self.name}"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, MutableMapping)"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport(self.code_model)
+        serialize_namespace_type = kwargs.get("serialize_namespace_type")
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        relative_path = self.code_model.get_relative_import_path(serialize_namespace, self.client_namespace)
+        alias = self.code_model.get_unique_types_alias(serialize_namespace, self.client_namespace)
+        if serialize_namespace_type in [NamespaceType.OPERATION, NamespaceType.CLIENT]:
+            file_import.add_submodule_import(
+                relative_path,
+                "types",
+                ImportType.LOCAL,
+                alias=alias,
+            )
+        return file_import

package/generator/pygen/codegen/models/operation.py

@@ -458,6 +458,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
                 r.type
                 and not isinstance(r.type, BinaryIteratorType)
                 and not xml_serializable(str(r.default_content_type))
+                and not (isinstance(r.type, ModelType) and r.type.is_typed_dict_only)
                 for r in self.responses
             ):
                 file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)

package/generator/pygen/codegen/models/paging_operation.py

@@ -186,7 +186,11 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
                 serialize_namespace, module_name="_utils.model_base"
             )
             file_import.merge(self.item_type.imports(**kwargs))
-            if self.default_error_deserialization(serialize_namespace) or self.need_deserialize:
+            need_deserialize_import = self.default_error_deserialization(serialize_namespace) or (
+                self.need_deserialize
+                and not (isinstance(self.item_type, ModelType) and self.item_type.is_typed_dict_only)
+            )
+            if need_deserialize_import:
                 file_import.add_submodule_import(relative_path, "_deserialize", ImportType.LOCAL)
             if self.is_xml_paging:
                 file_import.add_submodule_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")

package/generator/pygen/codegen/models/parameter.py

@@ -180,7 +180,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
         if isinstance(self.type, CombinedType) and self.type.name:
             file_import.add_submodule_import(
                 self.code_model.get_relative_import_path(serialize_namespace),
-                "_types",
+                "_unions",
                 ImportType.LOCAL,
                 TypingSection.TYPING,
             )
@@ -338,7 +338,7 @@ class Parameter(_ParameterBase):
     ) -> ParameterMethodLocation:
         if not self.in_method_signature:
             raise ValueError(f"Parameter '{self.client_name}' is not in the method.")
-        if self.code_model.options["models-mode"] == "dpg" and self.in_flattened_body:
+        if self.code_model.options["models-mode"] in ("dpg", "typeddict") and self.in_flattened_body:
             return ParameterMethodLocation.KEYWORD_ONLY
         if self.grouper:
             return ParameterMethodLocation.POSITIONAL