@typespec/http-client-python 0.35.1 → 0.37.0

package/generator/build/lib/pygen/preprocess/__init__.py

@@ -35,6 +35,8 @@ def update_overload_section(
         for overload_s, original_s in zip(overload[section], yaml_data[section]):
             if overload_s.get("type"):
                 overload_s["type"] = original_s["type"]
+            if overload_s.get("streaming"):
+                overload_s["streaming"] = original_s["streaming"]
             if overload_s.get("headers"):
                 for overload_h, original_h in zip(overload_s["headers"], original_s["headers"]):
                     if overload_h.get("type"):
@@ -81,8 +83,17 @@ def add_overload(yaml_data: dict[str, Any], body_type: dict[str, Any], for_flatt
     return overload
 
 
-def add_overloads_for_body_param(yaml_data: dict[str, Any]) -> None:
-    """If we added a body parameter type, add overloads for that type"""
+def add_overloads_for_body_param(yaml_data: dict[str, Any], skip_single_body_json: bool = False) -> None:
+    """If we added a body parameter type, add overloads for that type.
+
+    ``skip_single_body_json`` is the authoritative signal, computed by
+    ``add_body_param_type``, for whether a TypedDict-style overload was inserted
+    to replace the single-body raw-JSON overload on the spread (``base: json``)
+    path. It is True for both models-mode: dpg (generate-typeddict on) and
+    the TypedDict-only mode (models-mode: none with generate-typeddict on), and
+    False when TypedDict generation is disabled (in which case the single-body
+    raw-JSON overload is kept, matching pre-TypedDict behavior).
+    """
     body_parameter = yaml_data["bodyParameter"]
     if not (
         body_parameter["type"]["type"] == "combined"
@@ -94,8 +105,8 @@ def add_overloads_for_body_param(yaml_data: dict[str, Any]) -> None:
             continue
         if body_type.get("type") == "model" and body_type.get("base") == "json":
             yaml_data["overloads"].append(add_overload(yaml_data, body_type, for_flatten_params=True))
-            # Skip single-body JSON overload; the TypedDict overload replaces it
-            continue
+            if skip_single_body_json:
+                continue
         yaml_data["overloads"].append(add_overload(yaml_data, body_type))
     content_type_param = next(p for p in yaml_data["parameters"] if p["wireName"].lower() == "content-type")
     content_type_param["inOverload"] = False
@@ -306,6 +317,10 @@ class PreProcessPlugin(YamlUpdatePlugin):
     def is_tsp(self) -> bool:
         return self.options.get("tsp_file", False)
 
+    @property
+    def generate_typeddict(self) -> bool:
+        return self.options.get("generate-typeddict", True)
+
     @staticmethod
     def _find_existing_typeddict(
         code_model: dict[str, Any],
@@ -394,11 +409,39 @@ class PreProcessPlugin(YamlUpdatePlugin):
             if not existing_td:
                 code_model["types"].append(td_elem)
 
+    @staticmethod
+    def _insert_json_overload(
+        body_parameter: dict[str, Any],
+        origin_type: str,
+    ) -> None:
+        """Insert a raw-JSON (any-object) type into the body parameter's combined types.
+
+        This restores the pre-TypedDict dict-body overload used when TypedDict
+        generation is disabled.
+        """
+        if origin_type == "model":
+            body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
+        else:
+            # dict or list: copy the original container type and swap its element
+            # type for the raw-JSON any-object.
+            any_obj_list_or_dict = copy.deepcopy(body_parameter["type"]["types"][0])
+            any_obj_list_or_dict["elementType"] = KNOWN_TYPES["any-object"]
+            body_parameter["type"]["types"].insert(1, any_obj_list_or_dict)
+
     def add_body_param_type(
         self,
         code_model: dict[str, Any],
         body_parameter: dict[str, Any],
-    ):
+    ) -> bool:
+        """Build the combined body-parameter type and its overload variants.
+
+        Returns whether a TypedDict-style overload was inserted in place of the
+        single-body raw-JSON overload on the spread (``base: json``) path. The
+        caller passes this to ``add_overloads_for_body_param`` as
+        ``skip_single_body_json``. It is False when TypedDict generation is
+        disabled, so the pre-TypedDict single-body raw-JSON overload is kept.
+        """
+        skip_single_body_json = False
         # For a binary `bytes` body (e.g. content type application/octet-stream or a custom
         # binary media type), add an IO overload alongside the `bytes` one. This keeps backward
         # compatibility for services migrating from swagger, whose binary bodies were typed as IO.
@@ -408,7 +451,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
             body_parameter
             and body_parameter["type"]["type"] == "bytes"
             and is_binary_body
-            and self.options["models-mode"] != "typeddict"
+            and not self.options.generate_typeddict_only
             and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
         ):
             body_parameter["type"] = {
@@ -416,7 +459,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
             }
             code_model["types"].append(body_parameter["type"])
-            return
+            return skip_single_body_json
 
         # only add overload for special content type
         if (  # pylint: disable=too-many-boolean-expressions
@@ -432,7 +475,7 @@ class PreProcessPlugin(YamlUpdatePlugin):
             )
             is_dpg_model = model_type.get("base") == "dpg"
             is_json_model = model_type.get("base") == "json"
-            is_typeddict_only = self.options["models-mode"] == "typeddict"
+            is_typeddict_only = self.options.generate_typeddict_only
 
             body_parameter["type"] = {
                 "type": "combined",
@@ -442,11 +485,16 @@ class PreProcessPlugin(YamlUpdatePlugin):
             if not (self.is_tsp and has_multi_part_content_type(body_parameter)) and not is_typeddict_only:
                 body_parameter["type"]["types"].append(KNOWN_TYPES["binary"])
 
-            # Add typeddict overload for non-spread dpg models
+            # Add the dict-body overload for non-spread dpg models: a TypedDict when
+            # enabled, otherwise the raw-JSON overload (pre-TypedDict behavior).
             if self.options["models-mode"] == "dpg" and is_dpg_model:
-                cross_lang_id = model_type.get("crossLanguageDefinitionId")
-                existing_td = self._find_existing_typeddict(code_model, cross_lang_id, model_type.get("name"))
-                self._insert_typeddict_overload(code_model, body_parameter, model_type, origin_type, existing_td)
+                if self.generate_typeddict:
+                    cross_lang_id = model_type.get("crossLanguageDefinitionId")
+                    existing_td = self._find_existing_typeddict(code_model, cross_lang_id, model_type.get("name"))
+                    self._insert_typeddict_overload(code_model, body_parameter, model_type, origin_type, existing_td)
+                    skip_single_body_json = True
+                else:
+                    self._insert_json_overload(body_parameter, origin_type)
 
             # For spread bodies (json base), add a typeddict overload that references
             # the original model. This replaces the JSON single-body overload.
@@ -456,17 +504,20 @@ class PreProcessPlugin(YamlUpdatePlugin):
 
                 if is_typeddict_only and original:
                     # In typeddict-only mode, the original dpg model already renders
-                    # as a TypedDict — reference it directly, no copy needed.
+                    # as a TypedDict — reference it directly, no copy needed. It also
+                    # replaces the single-body JSON overload.
+                    skip_single_body_json = True
                     if origin_type == "model":
                         body_parameter["type"]["types"].insert(1, original)
                     else:
                         td_list_or_dict = copy.deepcopy(body_parameter["type"]["types"][0])
                         td_list_or_dict["elementType"] = original
                         body_parameter["type"]["types"].insert(1, td_list_or_dict)
-                else:
+                elif self.generate_typeddict:
                     source = original or model_type
                     existing_td = self._find_existing_typeddict(code_model, cross_lang_id, source.get("name"))
                     self._insert_typeddict_overload(code_model, body_parameter, source, origin_type, existing_td)
+                    skip_single_body_json = True
 
             if len(body_parameter["type"]["types"]) == 1:
                 # Only one body variant remains (e.g. typeddict-only mode where the
@@ -474,10 +525,12 @@ class PreProcessPlugin(YamlUpdatePlugin):
                 # wrapper back to the single type so we don't emit a lone
                 # ``@overload`` (mypy rejects a single overload definition).
                 body_parameter["type"] = body_parameter["type"]["types"][0]
-                return
+                return skip_single_body_json
 
             code_model["types"].append(body_parameter["type"])
 
+        return skip_single_body_json
+
     def pad_reserved_words(self, name: str, pad_type: PadType, yaml_type: dict[str, Any]) -> str:
         # we want to pad hidden variables as well
         if not name:
@@ -649,8 +702,8 @@ class PreProcessPlugin(YamlUpdatePlugin):
             response["discriminator"] = "operation"
         if body_parameter and not is_overload:
             # if we have a JSON body, we add a binary overload
-            self.add_body_param_type(code_model, body_parameter)
-            add_overloads_for_body_param(yaml_data)
+            skip_single_body_json = self.add_body_param_type(code_model, body_parameter)
+            add_overloads_for_body_param(yaml_data, skip_single_body_json=skip_single_body_json)
 
     def _update_lro_operation_helper(self, yaml_data: dict[str, Any]) -> None:
         for response in yaml_data.get("responses", []):

package/generator/build/lib/pygen/utils.py

@@ -28,6 +28,21 @@ def description_ends_with_code_block(description: str) -> bool:
     return all(not line.strip() or line.startswith((" ", "\t")) for line in lines[directives[-1] + 1 :])
 
 
+def is_typeddict_only(options: Any) -> bool:
+    """Whether generation is TypedDict-only.
+
+    True for TypeSpec input where no concrete models mode is selected (``models-mode: none``,
+    normalized to a falsy value by :class:`OptionsDict`) and ``generate-typeddict`` is enabled.
+    Swagger ``models-mode: none`` is left as a plain no-models mode because it never sets
+    ``tsp_file``.
+    """
+    return (
+        bool(options.get("tsp_file"))
+        and not options.get("models-mode")
+        and bool(options.get("generate-typeddict", True))
+    )
+
+
 def update_enum_value(name: str, value: Any, description: str, enum_type: dict[str, Any]) -> dict[str, Any]:
     return {
         "name": name,

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

@@ -1,15 +1,15 @@
 {
   "version": "1",
-  "pip_version": "26.2",
+  "pip_version": "26.2.1",
   "install": [
     {
       "download_info": {
-        "url": "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl",
+        "url": "https://pkgs.dev.azure.com/azure-sdk/29ec6040-b234-4e31-b139-33dc4287b756/_packaging/3572dbf9-b5ef-433b-9137-fc4d7768e7cc/pypi/download/setuptools/84/setuptools-84.0.0-py3-none-any.whl",
         "archive_info": {
           "hashes": {
-            "sha256": "29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3"
+            "sha256": "51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670"
           },
-          "hash": "sha256=29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3"
+          "hash": "sha256=51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670"
         }
       },
       "is_direct": false,
@@ -18,7 +18,7 @@
       "metadata": {
         "metadata_version": "2.4",
         "name": "setuptools",
-        "version": "83.0.0",
+        "version": "84.0.0",
         "dynamic": [
           "license-file"
         ],
@@ -122,13 +122,13 @@
   ],
   "environment": {
     "implementation_name": "cpython",
-    "implementation_version": "3.11.15",
+    "implementation_version": "3.11.16",
     "os_name": "posix",
     "platform_machine": "x86_64",
-    "platform_release": "6.17.0-1020-azure",
+    "platform_release": "6.17.0-1022-azure",
     "platform_system": "Linux",
-    "platform_version": "#20~24.04.1-Ubuntu SMP Fri Jun 19 20:09:14 UTC 2026",
-    "python_full_version": "3.11.15",
+    "platform_version": "#22-Ubuntu SMP Mon Jul 27 17:24:03 UTC 2026",
+    "python_full_version": "3.11.16",
     "platform_python_implementation": "CPython",
     "python_version": "3.11",
     "sys_platform": "linux"

package/generator/pygen/__init__.py

@@ -12,7 +12,7 @@ from abc import ABC, abstractmethod
 from typing import Any, Iterator, Optional, Union
 
 import yaml
-from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE
+from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE, is_typeddict_only
 
 from ._version import VERSION
 
@@ -36,6 +36,7 @@ class OptionsDict(MutableMapping):
         "low-level-client": False,
         "no-async": False,
         "no-namespace-folders": False,
+        "generate-typeddict": True,
         "polymorphic-examples": 5,
         "validate-versioning": True,
         "version-tolerant": True,
@@ -45,10 +46,20 @@ class OptionsDict(MutableMapping):
 
     def __init__(self, options: Optional[dict[str, Any]] = None) -> None:
         self._data = options.copy() if options else {}
+        # 'models-mode: typeddict' is deprecated. Represent it internally as 'none' models-mode with
+        # TypedDict generation enabled, so the rest of the codebase reasons in terms of models-mode
+        # plus the generate-typeddict flag.
+        if self._data.get("models-mode") == "typeddict":
+            self._data["generate-typeddict"] = True
         for key in list(self._data):
             self._data[key] = self._validate_and_transform(key, self._data[key])
         self._validate_combinations()
 
+    @property
+    def generate_typeddict_only(self) -> bool:
+        """Whether this is TypedDict-only generation ('models-mode: none' + TypedDicts)."""
+        return is_typeddict_only(self)
+
     def __getitem__(self, key: str) -> Any:  # pylint: disable=too-many-return-statements
         if key == "head-as-boolean" and self.get("azure-arm"):
             # override to always true if azure-arm is set
@@ -167,14 +178,22 @@ class OptionsDict(MutableMapping):
         if key == "builders-visibility" and value not in ["public", "hidden", "embedded"]:
             raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
 
+        if key == "models-mode" and value == "typeddict":
+            # Deprecated: keep accepting it for back-compat but store it as 'none' (falsy) with
+            # TypedDict generation enabled (see OptionsDict.__init__ and generate_typeddict_only).
+            _LOGGER.warning(
+                "'models-mode: typeddict' is deprecated. Use 'models-mode: none' with "
+                "'generate-typeddict: true' (the default) instead."
+            )
+            value = False
+
         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", "typeddict", False]:
+        if key == "models-mode" and value not in ["msrest", "dpg", False]:
             raise ValueError(
-                "--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."
+                "--models-mode can only be 'dpg' or 'none'. "
+                "Pass in 'dpg' for DPG models, or 'none' if you don't want any."
             )
         if key == "package-mode":
             if (

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

@@ -169,7 +169,9 @@ def build_type(yaml_data: dict[str, Any], code_model: CodeModel) -> BaseType:
         # need to special case model to avoid recursion
         if yaml_data["base"] == "typeddict":
             model_type = TypedDictModelType  # type: ignore
-        elif yaml_data["base"] == "json" or not code_model.options["models-mode"]:
+        elif yaml_data["base"] == "json" or (
+            not code_model.options["models-mode"] and not code_model.generate_typeddict_only
+        ):
             model_type = JSONModelType
         elif yaml_data["base"] == "dpg":
             model_type = DPGModelType  # type: ignore

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

@@ -17,6 +17,7 @@ from .operation_group import OperationGroup
 from .utils import NamespaceType
 from .._utils import DEFAULT_HEADER_TEXT, DEFAULT_LICENSE_DESCRIPTION
 from ... import OptionsDict
+from ...utils import is_typeddict_only
 
 
 def _is_legacy(options) -> bool:
@@ -89,7 +90,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         self.clients: list[Client] = [
             Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
         ]
-        if self.options["models-mode"] and self.model_types:
+        if (self.options["models-mode"] or self.generate_typeddict_only) and self.model_types:
             self.sort_model_types()
         self.named_unions: list[CombinedType] = [
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
@@ -174,6 +175,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     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 generate_typeddict_only(self) -> bool:
+        """Whether this is TypedDict-only generation ('models-mode: none' + TypedDicts)."""
+        return is_typeddict_only(self.options)
+
     @property
     def client_namespace_types(self) -> dict[str, ClientNamespaceType]:
         if not self._client_namespace_types:
@@ -273,12 +279,22 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             self.need_utils_utils(async_mode, client_namespace)
             or self.need_utils_serialization
             or self.options["models-mode"] == "dpg"
+            or self.has_structured_stream
         )
 
     @property
     def need_utils_serialization(self) -> bool:
         return not self.options["client-side-validation"]
 
+    @property
+    def has_structured_stream(self) -> bool:
+        return any(
+            op.has_structured_stream_response
+            for client in self.clients
+            for og in client.operation_groups
+            for op in og.operations
+        )
+
     def need_utils_utils(self, async_mode: bool, client_namespace: str) -> bool:
         return (
             self.need_utils_form_data(async_mode, client_namespace)
@@ -389,22 +405,26 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
     def _sort_model_types_helper(
         self,
         current: ModelType,
-        seen_schema_names: set[str],
+        seen_schema_keys: set[tuple[str, str]],
         seen_schema_yaml_ids: set[int],
     ):
         if current.id in seen_schema_yaml_ids:
             return []
-        if current.name in seen_schema_names:
-            raise ValueError(f"We have already generated a schema with name {current.name}")
+        current_schema_key = (current.client_namespace, current.name)
+        if current_schema_key in seen_schema_keys:
+            raise ValueError(
+                f"We have already generated a schema with name {current.name} "
+                f"in namespace {current.client_namespace}"
+            )
         ancestors = [current]
         if current.parents:
             for parent in current.parents:
                 if parent.id in seen_schema_yaml_ids:
                     continue
-                seen_schema_names.add(current.name)
+                seen_schema_keys.add(current_schema_key)
                 seen_schema_yaml_ids.add(current.id)
-                ancestors = self._sort_model_types_helper(parent, seen_schema_names, seen_schema_yaml_ids) + ancestors
-        seen_schema_names.add(current.name)
+                ancestors = self._sort_model_types_helper(parent, seen_schema_keys, seen_schema_yaml_ids) + ancestors
+        seen_schema_keys.add(current_schema_key)
         seen_schema_yaml_ids.add(current.id)
         return ancestors
 
@@ -414,11 +434,11 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
         :return: None
         :rtype: None
         """
-        seen_schema_names: set[str] = set()
+        seen_schema_keys: set[tuple[str, str]] = set()
         seen_schema_yaml_ids: set[int] = set()
         sorted_object_schemas: list[ModelType] = []
         for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
-            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_names, seen_schema_yaml_ids))
+            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_keys, seen_schema_yaml_ids))
         self.model_types = sorted_object_schemas
 
     @property

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

@@ -40,7 +40,7 @@ class EnumValue(BaseType):
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation"""
-        if self.code_model.options["models-mode"] == "typeddict":
+        if self.code_model.generate_typeddict_only:
             # A single constant enum value must be
             # annotated with its literal value directly (e.g. ``Literal["red"]``).
             return f"Literal[{self.value_type.get_declaration(self.value)}]"
@@ -83,7 +83,7 @@ class EnumValue(BaseType):
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
         file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
-        if self.code_model.options["models-mode"] == "typeddict":
+        if self.code_model.generate_typeddict_only:
             # In typeddict mode the enums module (``_enums.py``) is never generated
             return file_import
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
@@ -176,7 +176,7 @@ class EnumType(BaseType):
 
     @property
     def is_typeddict_mode(self) -> bool:
-        return self.code_model.options["models-mode"] == "typeddict"
+        return self.code_model.generate_typeddict_only
 
     def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation
@@ -184,7 +184,7 @@ class EnumType(BaseType):
         :return: The type annotation for this schema
         :rtype: str
         """
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             if self.is_typeddict_mode:
                 # In typeddict mode, enums are Literal aliases defined in types.py
                 serialize_namespace_type = kwargs.get("serialize_namespace_type")
@@ -203,6 +203,10 @@ class EnumType(BaseType):
                 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.enums_filename}." if self.internal else ""
+            if serialize_namespace_type == NamespaceType.TYPES_FILE:
+                # In types.py the enum symbol is imported directly (bare name), so no ``_enums.``
+                # module prefix even for internal enums — the prefix would be an undefined name.
+                file_name = ""
             model_name = module_name + file_name + self.name
             # we don't need quoted annotation in operation files, and need it in model folder files.
             if not kwargs.get("is_operation_file", False):
@@ -221,13 +225,13 @@ class EnumType(BaseType):
         return self.value_type.get_declaration(value)
 
     def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             return self.name
         return self.value_type.type_annotation(**kwargs)
 
     def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input and type annotation."""
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             type_annotation = self.value_type.type_annotation(**kwargs)
             enum_type_annotation = f"{self.client_namespace}.models.{self.name}"
             return f"{type_annotation} or ~{enum_type_annotation}"
@@ -261,7 +265,7 @@ class EnumType(BaseType):
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         file_import.merge(self.value_type.imports(**kwargs))
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             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")
@@ -305,9 +309,17 @@ class EnumType(BaseType):
                         typing_section=TypingSection.REGULAR,
                     )
                 elif serialize_namespace_type == NamespaceType.TYPES_FILE:
-                    # Import enum name directly to avoid dotted forward refs in TypedDict annotations
+                    # Import the enum symbol directly to avoid dotted forward refs in TypedDict
+                    # annotations. Internal enums are not re-exported from the public ``models``
+                    # package, so import them from the private ``_enums`` submodule instead — the
+                    # bare-symbol import (rather than the ``_enums`` module) also avoids name
+                    # collisions when internal enums come from several sibling namespaces.
+                    module_name = f"models.{self.code_model.enums_filename}" if self.internal else "models"
+                    enums_module = self.code_model.get_relative_import_path(
+                        serialize_namespace, self.client_namespace, module_name=module_name
+                    )
                     file_import.add_submodule_import(
-                        f"{relative_path}models" if relative_path != "." else ".models",
+                        enums_module,
                         self.name,
                         ImportType.LOCAL,
                         typing_section=TypingSection.TYPING,

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

@@ -38,6 +38,7 @@ class ListType(BaseType):
             self.code_model.options["version-tolerant"]
             and self.element_type.is_xml
             and not self.code_model.options["models-mode"]
+            and not self.code_model.generate_typeddict_only
         ):
             # this means we're version tolerant XML, we just return the XML element
             return self.element_type.type_annotation(**kwargs)

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

@@ -77,9 +77,7 @@ 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"
-        )
+        self.is_typed_dict_only: bool = self.yaml_data.get("typedDictOnly", False) or code_model.generate_typeddict_only
 
     @property
     def is_usage_output(self) -> bool:

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

@@ -104,6 +104,11 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             else self.has_stream_response
         )
 
+    @property
+    def has_structured_stream_response(self) -> bool:
+        """Whether any success response is a structured (JSONL / SSE) stream returning Stream[T]."""
+        return any(getattr(r, "is_structured_stream", False) for r in self.responses)
+
     @property
     def has_form_data_body(self):
         return self.parameters.has_form_data_body
@@ -334,7 +339,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             file_import.merge(
                 response.imports(async_mode=async_mode, need_import_iobase=self.need_import_iobase, **kwargs)
             )
-        if self.code_model.options["models-mode"]:
+        if self.code_model.options["models-mode"] or self.code_model.generate_typeddict_only:
             for exception in self.exceptions:
                 file_import.merge(exception.imports(async_mode=async_mode, **kwargs))
 
@@ -506,7 +511,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
 
     @property
     def has_stream_response(self) -> bool:
-        return any(r.is_stream_response for r in self.responses)
+        return any(r.is_stream_response or r.is_structured_stream for r in self.responses)
 
     @classmethod
     def get_request_builder(cls, yaml_data: dict[str, Any], client: "Client"):
@@ -552,7 +557,12 @@ class Operation(OperationBase[Response]):
                 "distributed_trace_async",
                 ImportType.SDKCORE,
             )
-        if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models-mode"]:
+        if (
+            self.has_response_body
+            and not self.has_optional_return_type
+            and not self.code_model.options["models-mode"]
+            and not self.code_model.generate_typeddict_only
+        ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
 
         return file_import

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

@@ -338,7 +338,9 @@ 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"] in ("dpg", "typeddict") and self.in_flattened_body:
+        if (
+            self.code_model.options["models-mode"] == "dpg" or self.code_model.generate_typeddict_only
+        ) and self.in_flattened_body:
             return ParameterMethodLocation.KEYWORD_ONLY
         if self.grouper:
             return ParameterMethodLocation.POSITIONAL