@typespec/http-client-python 0.15.2 → 0.16.1-dev.0

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

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, List, Any, Optional, Union, TYPE_CHECKING, cast, TypeVar
+from typing import Any, Optional, Union, TYPE_CHECKING, cast, TypeVar
 
 from .operation import Operation, OperationBase
 from .response import PagingResponse, LROPagingResponse, Response
@@ -28,16 +28,16 @@ PagingResponseType = TypeVar("PagingResponseType", bound=Union[PagingResponse, L
 class PagingOperationBase(OperationBase[PagingResponseType]):
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         client: "Client",
         name: str,
         request_builder: RequestBuilder,
         parameters: ParameterList,
-        responses: List[PagingResponseType],
-        exceptions: List[Response],
+        responses: list[PagingResponseType],
+        exceptions: list[Response],
         *,
-        overloads: Optional[List[Operation]] = None,
+        overloads: Optional[list[Operation]] = None,
         override_success_response_to_200: bool = False,
     ) -> None:
         super().__init__(
@@ -59,8 +59,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         self.override_success_response_to_200 = override_success_response_to_200
         self.pager_sync: str = yaml_data.get("pagerSync") or f"{self.code_model.core_library}.paging.ItemPaged"
         self.pager_async: str = yaml_data.get("pagerAsync") or f"{self.code_model.core_library}.paging.AsyncItemPaged"
-        self.continuation_token: Dict[str, Any] = yaml_data.get("continuationToken", {})
-        self.next_link_reinjected_parameters: List[Parameter] = [
+        self.continuation_token: dict[str, Any] = yaml_data.get("continuationToken", {})
+        self.next_link_reinjected_parameters: list[Parameter] = [
             Parameter.from_yaml(p, code_model) for p in yaml_data.get("nextLinkReInjectedParameters", [])
         ]
 
@@ -119,8 +119,14 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def cls_type_annotation(self, *, async_mode: bool, **kwargs: Any) -> str:
         return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode, **kwargs)}]"
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = super()._imports_shared(async_mode, **kwargs)
+    @property
+    def has_optional_return_type(self) -> bool:
+        return False
+
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport(self.code_model)
+        file_import = super().imports(async_mode, **kwargs)
         if async_mode:
             default_paging_submodule = f"{'async_' if self.code_model.is_azure_flavor else ''}paging"
             file_import.add_submodule_import(
@@ -139,16 +145,6 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             and not async_mode
         ):
             file_import.merge(self.next_request_builder.imports(**kwargs))
-        return file_import
-
-    @property
-    def has_optional_return_type(self) -> bool:
-        return False
-
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        if self.abstract:
-            return FileImport(self.code_model)
-        file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, **kwargs))
         serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
         if self.code_model.options["tracing"] and self.want_tracing:

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

@@ -7,10 +7,8 @@ import abc
 from enum import Enum
 
 from typing import (
-    Dict,
     Any,
     TYPE_CHECKING,
-    List,
     Optional,
     TypeVar,
     Union,
@@ -35,6 +33,7 @@ class ParameterLocation(str, Enum):
     ENDPOINT_PATH = "endpointPath"
     QUERY = "query"
     BODY = "body"
+    KEYWORD = "keyword"
     OTHER = "other"
 
 
@@ -56,7 +55,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:
@@ -75,13 +74,13 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
         self.grouped_by: Optional[str] = self.yaml_data.get("groupedBy")
         # property matching property name to parameter name for grouping params
         # and flattened body params
-        self.property_to_parameter_name: Optional[Dict[str, str]] = self.yaml_data.get("propertyToParameterName")
+        self.property_to_parameter_name: Optional[dict[str, str]] = self.yaml_data.get("propertyToParameterName")
         self.flattened: bool = self.yaml_data.get("flattened", False)
         self.in_flattened_body: bool = self.yaml_data.get("inFlattenedBody", False)
         self.grouper: bool = self.yaml_data.get("grouper", False)
         self.check_client_input: bool = self.yaml_data.get("checkClientInput", False)
         self.added_on: Optional[str] = self.yaml_data.get("addedOn")
-        self.api_versions: Optional[List[str]] = self.yaml_data.get("apiVersions", [])
+        self.api_versions: Optional[list[str]] = self.yaml_data.get("apiVersions", [])
         self.is_api_version: bool = self.yaml_data.get("isApiVersion", False)
         self.in_overload: bool = self.yaml_data.get("inOverload", False)
         self.default_to_unset_sentinel: bool = self.yaml_data.get("defaultToUnsetSentinel", False)
@@ -160,7 +159,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
     def serialization_type(self, **kwargs: Any) -> str:
         return self.type.serialization_type(**kwargs)
 
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
+    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
@@ -178,10 +177,6 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
                 ImportType.LOCAL,
                 TypingSection.TYPING,
             )
-        return file_import
-
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
         # special logic for api-version parameter
         if not self.is_api_version:
             file_import.merge(self.type.imports(async_mode=async_mode, **kwargs))
@@ -193,11 +188,6 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
             )
         return file_import
 
-    def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.merge(self.type.imports_for_multiapi(async_mode=async_mode, **kwargs))
-        return file_import
-
     @property
     def method_location(self) -> ParameterMethodLocation:
         raise NotImplementedError("Please implement in children")
@@ -227,7 +217,7 @@ class BodyParameter(_ParameterBase):
     """Body parameter."""
 
     @property
-    def entries(self) -> List["BodyParameter"]:
+    def entries(self) -> list["BodyParameter"]:
         return [BodyParameter.from_yaml(e, self.code_model) for e in self.yaml_data.get("entries", [])]
 
     @property
@@ -258,7 +248,7 @@ class BodyParameter(_ParameterBase):
         return not (self.flattened or self.grouped_by)
 
     @property
-    def content_types(self) -> List[str]:
+    def content_types(self) -> list[str]:
         return self.yaml_data["contentTypes"]
 
     @property
@@ -280,11 +270,10 @@ class BodyParameter(_ParameterBase):
                 "prepare_multipart_form_data",
                 ImportType.LOCAL,
             )
-            file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BodyParameter":
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel") -> "BodyParameter":
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
@@ -300,7 +289,7 @@ class Parameter(_ParameterBase):
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
         type: BaseType,
     ) -> None:
@@ -364,7 +353,7 @@ class Parameter(_ParameterBase):
         return ParameterMethodLocation.POSITIONAL
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel"):
         return cls(
             yaml_data=yaml_data,
             code_model=code_model,
@@ -396,6 +385,8 @@ class ClientParameter(Parameter):
             and not self.code_model.options["azure-arm"]
         ):
             return ParameterMethodLocation.KEYWORD_ONLY
+        if self.location == ParameterLocation.KEYWORD:
+            return ParameterMethodLocation.KEYWORD_ONLY
         return ParameterMethodLocation.POSITIONAL
 
 

package/generator/build/lib/pygen/codegen/models/parameter_list.py

@@ -7,8 +7,6 @@ import logging
 from typing import (
     Any,
     Callable,
-    Dict,
-    List,
     Optional,
     TYPE_CHECKING,
     Union,
@@ -48,7 +46,7 @@ class ParameterImplementation(Enum):
 _LOGGER = logging.getLogger(__name__)
 
 
-def method_signature_helper(positional: List[str], keyword_only: Optional[List[str]], kwarg_params: List[str]):
+def method_signature_helper(positional: list[str], keyword_only: Optional[list[str]], kwarg_params: list[str]):
     keyword_only = keyword_only or []
     return positional + keyword_only + kwarg_params
 
@@ -64,9 +62,9 @@ class _ParameterListBase(
 
     def __init__(
         self,
-        yaml_data: Dict[str, Any],
+        yaml_data: dict[str, Any],
         code_model: "CodeModel",
-        parameters: List[ParameterType],
+        parameters: list[ParameterType],
         body_parameter: Optional[BodyParameterType] = None,
     ) -> None:
         self.yaml_data = yaml_data
@@ -97,18 +95,18 @@ class _ParameterListBase(
 
     @staticmethod
     @abstractmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ParameterType]:
+    def parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], ParameterType]:
         """Callable for creating parameters"""
 
     @staticmethod
     @abstractmethod
-    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], BodyParameterType]:
+    def body_parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], BodyParameterType]:
         """Callable for creating body parameters"""
 
     @property
-    def grouped(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def grouped(self) -> list[Union[ParameterType, BodyParameterType]]:
         """All parameters that are inside a parameter group"""
-        params: List[Union[ParameterType, BodyParameterType]] = [p for p in self.parameters if p.grouped_by]
+        params: list[Union[ParameterType, BodyParameterType]] = [p for p in self.parameters if p.grouped_by]
         if self.has_body and self.body_parameter.grouped_by:
             params.append(self.body_parameter)
         return params
@@ -123,41 +121,41 @@ class _ParameterListBase(
         return bool(self._body_parameter)
 
     @property
-    def path(self) -> List[ParameterType]:
+    def path(self) -> list[ParameterType]:
         """All path parameters"""
         return [p for p in self.parameters if p.location in (ParameterLocation.PATH, ParameterLocation.ENDPOINT_PATH)]
 
     @property
-    def query(self) -> List[ParameterType]:
+    def query(self) -> list[ParameterType]:
         """All query parameters"""
         return [p for p in self.parameters if p.location == ParameterLocation.QUERY]
 
     @property
-    def headers(self) -> List[ParameterType]:
+    def headers(self) -> list[ParameterType]:
         """All header parameters"""
         return [p for p in self.parameters if p.location == ParameterLocation.HEADER]
 
     @property
-    def constant(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def constant(self) -> list[Union[ParameterType, BodyParameterType]]:
         """All constant parameters"""
         return [p for p in self.parameters if p.constant]
 
     @property
-    def positional(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def positional(self) -> list[Union[ParameterType, BodyParameterType]]:
         """All positional parameters"""
         return _sort(
             [p for p in self.unsorted_method_params if p.method_location == ParameterMethodLocation.POSITIONAL]
         )
 
     @property
-    def keyword_only(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def keyword_only(self) -> list[Union[ParameterType, BodyParameterType]]:
         """All keyword only parameters"""
         return _sort(
             [p for p in self.unsorted_method_params if p.method_location == ParameterMethodLocation.KEYWORD_ONLY]
         )
 
     @property
-    def kwarg(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def kwarg(self) -> list[Union[ParameterType, BodyParameterType]]:
         """All kwargs"""
         return _sort([p for p in self.unsorted_method_params if p.method_location == ParameterMethodLocation.KWARG])
 
@@ -174,9 +172,9 @@ class _ParameterListBase(
         """Whether this is a client or a method parameter"""
 
     @property
-    def unsorted_method_params(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def unsorted_method_params(self) -> list[Union[ParameterType, BodyParameterType]]:
         """Method params before sorting"""
-        method_params: List[Union[ParameterType, BodyParameterType]] = [
+        method_params: list[Union[ParameterType, BodyParameterType]] = [
             p
             for p in self.parameters
             if p.in_method_signature
@@ -196,11 +194,11 @@ class _ParameterListBase(
         return method_params
 
     @property
-    def method(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def method(self) -> list[Union[ParameterType, BodyParameterType]]:
         """Sorted method params. First positional, then keyword only, then kwarg"""
         return self.positional + self.keyword_only + self.kwarg
 
-    def method_signature(self, async_mode: bool, **kwargs: Any) -> List[str]:
+    def method_signature(self, async_mode: bool, **kwargs: Any) -> list[str]:
         """Method signature for this parameter list."""
         return method_signature_helper(
             positional=self.method_signature_positional(async_mode, **kwargs),
@@ -208,11 +206,11 @@ class _ParameterListBase(
             kwarg_params=self.method_signature_kwargs,
         )
 
-    def method_signature_positional(self, async_mode: bool, **kwargs: Any) -> List[str]:
+    def method_signature_positional(self, async_mode: bool, **kwargs: Any) -> list[str]:
         """Signature for positional parameters"""
         return [parameter.method_signature(async_mode, **kwargs) for parameter in self.positional]
 
-    def method_signature_keyword_only(self, async_mode: bool, **kwargs: Any) -> List[str]:
+    def method_signature_keyword_only(self, async_mode: bool, **kwargs: Any) -> list[str]:
         """Signature for keyword only parameters"""
         result = [
             parameter.method_signature(async_mode, **kwargs)
@@ -222,19 +220,19 @@ class _ParameterListBase(
         return ["*,"] + result if result else []
 
     @property
-    def method_signature_kwargs(self) -> List[str]:
+    def method_signature_kwargs(self) -> list[str]:
         """Signature for kwargs"""
         return ["**kwargs: Any"]
 
     @property
-    def kwargs_to_pop(self) -> List[Union[ParameterType, BodyParameterType]]:
+    def kwargs_to_pop(self) -> list[Union[ParameterType, BodyParameterType]]:
         """Method kwargs we want to pop"""
         # don't want to pop bodies unless it's a constant
         kwargs_to_pop = self.kwarg
         return [k for k in kwargs_to_pop if k.location != ParameterLocation.BODY or k.constant]
 
     @property
-    def call(self) -> List[str]:
+    def call(self) -> list[str]:
         """How to pass in parameters to call the operation"""
         retval = [p.client_name for p in self.method if p.method_location == ParameterMethodLocation.POSITIONAL]
         retval.extend(
@@ -248,7 +246,7 @@ class _ParameterListBase(
         return retval
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel"):
+    def from_yaml(cls, yaml_data: dict[str, Any], code_model: "CodeModel"):
         parameters = [cls.parameter_creator()(parameter, code_model) for parameter in yaml_data["parameters"]]
         body_parameter = None
         if yaml_data.get("bodyParameter"):
@@ -264,11 +262,11 @@ class _ParameterListBase(
 class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], Parameter]:
+    def parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], Parameter]:
         return Parameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], BodyParameter]:
+    def body_parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], BodyParameter]:
         return BodyParameter.from_yaml
 
     @property
@@ -276,7 +274,7 @@ class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):
         return "Method"
 
     @property
-    def path(self) -> List[Parameter]:
+    def path(self) -> list[Parameter]:
         return [k for k in super().path if k.location == ParameterLocation.ENDPOINT_PATH]
 
 
@@ -288,11 +286,11 @@ class _RequestBuilderParameterList(_ParameterListBase[RequestBuilderParameter, R
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameter]:
+    def parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], RequestBuilderParameter]:
         return RequestBuilderParameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameter]:
+    def body_parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], RequestBuilderBodyParameter]:
         return RequestBuilderBodyParameter.from_yaml
 
     @property
@@ -302,7 +300,7 @@ class _RequestBuilderParameterList(_ParameterListBase[RequestBuilderParameter, R
     @property
     def unsorted_method_params(
         self,
-    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
+    ) -> list[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
         # don't have access to client params in request builder
         retval = [
             p
@@ -313,13 +311,13 @@ class _RequestBuilderParameterList(_ParameterListBase[RequestBuilderParameter, R
         return retval
 
     @property
-    def path(self) -> List[RequestBuilderParameter]:
+    def path(self) -> list[RequestBuilderParameter]:
         return [p for p in super().path if p.location != ParameterLocation.ENDPOINT_PATH]
 
     @property
     def constant(
         self,
-    ) -> List[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
+    ) -> list[Union[RequestBuilderParameter, RequestBuilderBodyParameter]]:
         """All constant parameters"""
         return [p for p in super().constant if p.location != ParameterLocation.ENDPOINT_PATH]
 
@@ -336,7 +334,7 @@ class _ClientGlobalParameterList(_ParameterListBase[ParameterType, BodyParameter
     """Base parameter list for client and config classes"""
 
     @staticmethod
-    def body_parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], BodyParameter]:
+    def body_parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], BodyParameter]:
         return BodyParameter.from_yaml
 
     @property
@@ -351,7 +349,7 @@ class _ClientGlobalParameterList(_ParameterListBase[ParameterType, BodyParameter
             return None
 
     @property
-    def path(self) -> List[ParameterType]:
+    def path(self) -> list[ParameterType]:
         return [p for p in super().path if p.location == ParameterLocation.ENDPOINT_PATH]
 
 
@@ -359,11 +357,11 @@ class ClientGlobalParameterList(_ClientGlobalParameterList[ClientParameter]):
     """Parameter list for Client class"""
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ClientParameter]:
+    def parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], ClientParameter]:
         return ClientParameter.from_yaml
 
     @property
-    def path(self) -> List[ClientParameter]:
+    def path(self) -> list[ClientParameter]:
         return [p for p in super().path if not p.is_host]
 
     @property
@@ -379,7 +377,7 @@ class ConfigGlobalParameterList(_ClientGlobalParameterList[ConfigParameter]):
     """Parameter list for config"""
 
     @staticmethod
-    def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], ConfigParameter]:
+    def parameter_creator() -> Callable[[dict[str, Any], "CodeModel"], ConfigParameter]:
         return ConfigParameter.from_yaml
 
     @property

package/generator/build/lib/pygen/codegen/models/primitive_types.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 import datetime
 import decimal
-from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
+from typing import Any, Optional, Union, TYPE_CHECKING
 
 from .base import BaseType
 from .imports import FileImport, ImportType, TypingSection
@@ -61,7 +61,7 @@ class BooleanType(PrimitiveType):
 
 
 class BinaryType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
@@ -176,7 +176,7 @@ class AnyObjectType(PrimitiveType):
 
 
 class NumberType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.precision: Optional[int] = yaml_data.get("precision")
         self.multiple: Optional[int] = yaml_data.get("multipleOf")
@@ -186,7 +186,7 @@ class NumberType(PrimitiveType):
         self.exclusive_minimum: Optional[int] = yaml_data.get("exclusiveMinimum")
 
     @property
-    def serialization_constraints(self) -> List[str]:
+    def serialization_constraints(self) -> list[str]:
         validation_constraints = [
             (f"maximum_ex={self.maximum}" if self.maximum is not None and self.exclusive_maximum else None),
             (f"maximum={self.maximum}" if self.maximum is not None and not self.exclusive_maximum else None),
@@ -197,8 +197,8 @@ class NumberType(PrimitiveType):
         return [x for x in validation_constraints if x is not None]
 
     @property
-    def validation(self) -> Optional[Dict[str, Union[bool, int, str]]]:
-        validation: Dict[str, Union[bool, int, str]] = {}
+    def validation(self) -> Optional[dict[str, Union[bool, int, str]]]:
+        validation: dict[str, Union[bool, int, str]] = {}
         if self.maximum is not None:
             if self.exclusive_maximum:
                 validation["maximum_ex"] = self.maximum
@@ -221,7 +221,7 @@ class NumberType(PrimitiveType):
 
 class IntegerType(NumberType):
 
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         if yaml_data.get("encode") == "string":
             self.encode = "str"
@@ -294,7 +294,7 @@ class DecimalType(NumberType):
 
 
 class StringType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.max_length: Optional[int] = yaml_data.get("maxLength")
         self.min_length: Optional[int] = (
@@ -303,7 +303,7 @@ class StringType(PrimitiveType):
         self.pattern: Optional[str] = yaml_data.get("pattern")
 
     @property
-    def serialization_constraints(self) -> List[str]:
+    def serialization_constraints(self) -> list[str]:
         validation_constraints = [
             f"max_length={self.max_length}" if self.max_length is not None else None,
             f"min_length={self.min_length}" if self.min_length is not None else None,
@@ -312,8 +312,8 @@ class StringType(PrimitiveType):
         return [x for x in validation_constraints if x is not None]
 
     @property
-    def validation(self) -> Optional[Dict[str, Union[bool, int, str]]]:
-        validation: Dict[str, Union[bool, int, str]] = {}
+    def validation(self) -> Optional[dict[str, Union[bool, int, str]]]:
+        validation: dict[str, Union[bool, int, str]] = {}
         if self.max_length is not None:
             validation["max_length"] = self.max_length
         if self.min_length is not None:
@@ -338,7 +338,7 @@ class StringType(PrimitiveType):
 
 
 class DatetimeType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = (
             "rfc3339"
@@ -564,7 +564,7 @@ class DurationType(PrimitiveType):
 
 
 class ByteArraySchema(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = yaml_data.get("encode", "base64")
 
@@ -585,20 +585,26 @@ class ByteArraySchema(PrimitiveType):
 
 
 class SdkCoreType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = yaml_data.get("name", "")
         self.submodule = yaml_data.get("submodule", "")
+        self.is_typing_only = yaml_data.get("isTypingOnly", False)
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.code_model.core_library}.{self.type_annotation(**kwargs)}"
+        return f"~{self.code_model.core_library}.{self.name}"
 
     def type_annotation(self, **kwargs: Any) -> str:
-        return self.name
+        return f'"{self.name}"' if self.is_typing_only else self.name
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
-        file_import.add_submodule_import(self.submodule, self.name, ImportType.SDKCORE)
+        file_import.add_submodule_import(
+            self.submodule,
+            self.name,
+            ImportType.SDKCORE,
+            typing_section=TypingSection.TYPING if self.is_typing_only else TypingSection.REGULAR,
+        )
         return file_import
 
     @property
@@ -610,7 +616,7 @@ class SdkCoreType(PrimitiveType):
 
 
 class MultiPartFileType(PrimitiveType):
-    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+    def __init__(self, yaml_data: dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = "FileType"