openapi-python-client 0.28.4__py3-none-any.whl → 0.29.1__py3-none-any.whl

openapi_python_client/parser/properties/union.py

@@ -4,13 +4,13 @@ from collections.abc import Iterator
 from itertools import chain
 from typing import Any, ClassVar, cast
 
-from attr import define, evolve
+from attr import define, evolve, field
 
-from ... import Config
+from ... import Config, strings
 from ... import schema as oai
-from ...utils import PythonIdentifier
+from ...strings import PythonIdentifier
 from ..errors import ParseError, PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 from .schemas import Schemas
 
 
@@ -18,12 +18,12 @@ from .schemas import Schemas
 class UnionProperty(PropertyProtocol):
     """A property representing a Union (anyOf) of other properties"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
     inner_properties: list[PropertyProtocol]
     template: ClassVar[str] = "union_property.py.jinja"
 
@@ -32,7 +32,7 @@ class UnionProperty(PropertyProtocol):
         cls,
         *,
         data: oai.Schema,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         schemas: Schemas,
         parent_name: str,
@@ -70,12 +70,12 @@ class UnionProperty(PropertyProtocol):
                 and sub_prop_data.title is not None
                 and sub_prop_data.title != data.title
             ):
-                subscript = sub_prop_data.title
+                subscript = sub_prop_data.title.get_untrusted_value()
             else:
                 subscript = f"type_{i}"
 
             sub_prop, schemas = property_from_data(
-                name=f"{name}_{subscript}",
+                name=oai.UntrustedString(f"{name.get_untrusted_value()}_{subscript}"),
                 required=True,
                 data=sub_prop_data,
                 schemas=schemas,
@@ -120,7 +120,7 @@ class UnionProperty(PropertyProtocol):
         prop = evolve(prop, default=default_or_error)
         return prop, schemas
 
-    def convert_value(self, value: Any) -> Value | None | PropertyError:
+    def convert_value(self, value: Any) -> Value | PropertyError | None:
         if value is None or isinstance(value, Value):
             return None
         value_or_error: Value | PropertyError | None = PropertyError(
@@ -132,7 +132,7 @@ class UnionProperty(PropertyProtocol):
                 return value_or_error
         return value_or_error
 
-    def _get_inner_type_strings(self, json: bool) -> set[str]:
+    def _get_inner_type_strings(self, json: bool) -> set[strings.PythonCode]:
         return {
             p.get_type_string(
                 no_optional=True,
@@ -142,18 +142,19 @@ class UnionProperty(PropertyProtocol):
         }
 
     @staticmethod
-    def _get_type_string_from_inner_type_strings(inner_types: set[str]) -> str:
+    def _get_type_string_from_inner_type_strings(inner_types: set[strings.PythonCode]) -> strings.PythonCode:
         if len(inner_types) == 1:
             return inner_types.pop()
-        return " | ".join(sorted(inner_types, key=lambda x: x.lower()))
+        joined = " | ".join(sorted((t.as_unembedded_code() for t in inner_types), key=str.lower))
+        return strings.PythonCode(joined)
 
-    def get_base_type_string(self) -> str:
+    def get_base_type_string(self) -> strings.PythonCode:
         return self._get_type_string_from_inner_type_strings(self._get_inner_type_strings(json=False))
 
-    def get_base_json_type_string(self) -> str:
+    def get_base_json_type_string(self) -> strings.PythonCode:
         return self._get_type_string_from_inner_type_strings(self._get_inner_type_strings(json=True))
 
-    def get_type_strings_in_union(self, *, no_optional: bool = False, json: bool) -> set[str]:
+    def get_type_strings_in_union(self, *, no_optional: bool = False, json: bool) -> set[strings.PythonCode]:
         """
         Get the set of all the types that should appear within the `Union` representing this property.
 
@@ -164,22 +165,22 @@ class UnionProperty(PropertyProtocol):
             json: If True, this returns the JSON types, not the Python types, of this property.
 
         Returns:
-            A set of strings containing the types that should appear within `Union`.
+            A set of code snippets containing the types that should appear within `Union`.
         """
         type_strings = self._get_inner_type_strings(json=json)
         if no_optional:
             return type_strings
         if not self.required:
-            type_strings.add("Unset")
+            type_strings.add(strings.PythonCode("Unset"))
         return type_strings
 
     def get_type_string(
         self,
         no_optional: bool = False,
         json: bool = False,
-    ) -> str:
+    ) -> strings.PythonCode:
         """
-        Get a string representation of type that should be used when declaring this property.
+        Get a Python code representation of type that should be used when declaring this property.
         This implementation differs slightly from `Property.get_type_string` in order to collapse
         nested union types.
         """
@@ -212,5 +213,6 @@ class UnionProperty(PropertyProtocol):
 
         for inner_prop in self.inner_properties:
             if evolve(cast(Property, inner_prop), required=self.required).validate_location(location) is not None:
-                return ParseError(detail=f"{self.get_type_string()} is not allowed in {location}")
+                type_string = self.get_type_string().as_unembedded_code()
+                return ParseError(detail=f"{type_string} is not allowed in {location}")
         return None

openapi_python_client/parser/properties/uuid.py

@@ -3,24 +3,24 @@ from __future__ import annotations
 from typing import Any, ClassVar
 from uuid import UUID
 
-from attr import define
+from attr import define, field
 
 from ... import schema as oai
-from ...utils import PythonIdentifier
+from ...strings import PythonCode, PythonIdentifier
 from ..errors import PropertyError
-from .protocol import PropertyProtocol, Value
+from .protocol import PropertyProtocol, Value, convert_example
 
 
 @define
 class UuidProperty(PropertyProtocol):
     """A property of type uuid.UUID"""
 
-    name: str
+    name: oai.UntrustedString
     required: bool
     default: Value | None
     python_name: PythonIdentifier
-    description: str | None
-    example: str | None
+    description: oai.UntrustedString | None
+    example: oai.UntrustedString | None = field(converter=convert_example)
 
     _type_string: ClassVar[str] = "UUID"
     _json_type_string: ClassVar[str] = "str"
@@ -35,12 +35,12 @@ class UuidProperty(PropertyProtocol):
     @classmethod
     def build(
         cls,
-        name: str,
+        name: oai.UntrustedString,
         required: bool,
         default: Any,
         python_name: PythonIdentifier,
-        description: str | None,
-        example: str | None,
+        description: oai.UntrustedString | None,
+        example: Any,
     ) -> UuidProperty | PropertyError:
         checked_default = cls.convert_value(default)
         if isinstance(checked_default, PropertyError):
@@ -56,7 +56,7 @@ class UuidProperty(PropertyProtocol):
         )
 
     @classmethod
-    def convert_value(cls, value: Any) -> Value | None | PropertyError:
+    def convert_value(cls, value: Any) -> Value | PropertyError | None:
         if value is None or isinstance(value, Value):
             return value
         if isinstance(value, str):
@@ -64,7 +64,7 @@ class UuidProperty(PropertyProtocol):
                 UUID(value)
             except ValueError:
                 return PropertyError(f"Invalid UUID value: {value}")
-            return Value(python_code=f"UUID('{value}')", raw_value=value)
+            return Value(python_code=PythonCode(f"UUID('{value}')"), raw_value=value)
         return PropertyError(f"Invalid UUID value: {value}")
 
     def get_imports(self, *, prefix: str) -> set[str]:

openapi_python_client/parser/responses.py

@@ -5,12 +5,13 @@ from typing import TypedDict
 
 from attrs import define
 
-from openapi_python_client import utils
+from openapi_python_client import strings
 from openapi_python_client.parser.properties.schemas import get_reference_simple_name, parse_reference_path
 
 from .. import Config
 from .. import schema as oai
-from ..utils import PythonIdentifier
+from ..schema.untrusted_string import UntrustedString
+from ..strings import PythonIdentifier
 from .errors import ParseError, PropertyError
 from .properties import AnyProperty, Property, Schemas, property_from_data
 
@@ -60,22 +61,23 @@ class HTTPStatusPattern:
         self.range = code_range
 
     @staticmethod
-    def parse(pattern: str) -> "HTTPStatusPattern | ParseError":
+    def parse(pattern: UntrustedString) -> "HTTPStatusPattern | ParseError":
         """Parse a status code pattern such as 2XX or 404"""
-        if pattern == "default":
-            return HTTPStatusPattern(pattern=pattern, code_range=None)
+        untrusted = pattern.get_untrusted_value()
+        if untrusted == "default":
+            return HTTPStatusPattern(pattern=untrusted, code_range=None)
 
-        if pattern.endswith("XX") and pattern[0].isdigit():
-            first_digit = int(pattern[0])
-            return HTTPStatusPattern(pattern=pattern, code_range=(first_digit * 100, first_digit * 100 + 99))
+        if len(untrusted) == 3 and untrusted.endswith("XX") and untrusted[0].isdigit():
+            first_digit = int(untrusted[0])
+            return HTTPStatusPattern(pattern=untrusted, code_range=(first_digit * 100, first_digit * 100 + 99))
 
         try:
-            code = int(pattern)
-            return HTTPStatusPattern(pattern=pattern, code_range=(code, code))
+            code = int(untrusted)
+            return HTTPStatusPattern(pattern=untrusted, code_range=(code, code))
         except ValueError:
             return ParseError(
                 detail=(
-                    f"Invalid response status code pattern: {pattern}, response will be omitted from generated client"
+                    f"Invalid response status code pattern: {untrusted}, response will be omitted from generated client"
                 )
             )
 
@@ -129,7 +131,7 @@ class Response:
 
 
 def _source_by_content_type(content_type: str, config: Config) -> _ResponseSource | None:
-    parsed_content_type = utils.get_content_type(content_type, config)
+    parsed_content_type = strings.get_content_type(content_type, config)
     if parsed_content_type is None:
         return None
 
@@ -150,7 +152,7 @@ def _source_by_content_type(content_type: str, config: Config) -> _ResponseSourc
 def empty_response(
     *,
     status_code: HTTPStatusPattern,
-    response_name: str,
+    response_name: UntrustedString,
     config: Config,
     data: oai.Response | oai.Reference,
 ) -> Response:
@@ -175,23 +177,25 @@ def response_from_data(  # noqa: PLR0911
     status_code: HTTPStatusPattern,
     data: oai.Response | oai.Reference,
     schemas: Schemas,
-    responses: dict[str, oai.Response | oai.Reference],
+    responses: dict[UntrustedString, oai.Response | oai.Reference],
     parent_name: str,
     config: Config,
 ) -> tuple[Response | ParseError, Schemas]:
     """Generate a Response from the OpenAPI dictionary representation of it"""
 
-    response_name = f"response_{status_code.pattern}"
+    response_name = UntrustedString(f"response_{status_code.pattern}")
     if isinstance(data, oai.Reference):
         ref_path = parse_reference_path(data.ref)
-        if isinstance(ref_path, ParseError):
+        if isinstance(ref_path, ParseError):  # pragma: no cover
             return ref_path, schemas
-        if not ref_path.startswith("/components/responses/"):
-            return ParseError(data=data, detail=f"$ref to {data.ref} not allowed in responses"), schemas
+        if not ref_path.startswith("/components/responses/"):  # pragma: no cover
+            return ParseError(
+                data=data, detail=f"$ref to {data.ref.get_untrusted_value()} not allowed in responses"
+            ), schemas
         resp_data = responses.get(get_reference_simple_name(ref_path), None)
-        if not resp_data:
-            return ParseError(data=data, detail=f"Could not find reference: {data.ref}"), schemas
-        if not isinstance(resp_data, oai.Response):
+        if not resp_data:  # pragma: no cover
+            return ParseError(data=data, detail=f"Could not find reference: {data.ref.get_untrusted_value()}"), schemas
+        if not isinstance(resp_data, oai.Response):  # pragma: no cover
             return ParseError(data=data, detail="Top-level $ref inside components/responses is not supported"), schemas
         data = resp_data
 
@@ -208,13 +212,16 @@ def response_from_data(  # noqa: PLR0911
         )
 
     for content_type, media_type in content.items():
-        source = _source_by_content_type(content_type, config)
+        source = _source_by_content_type(content_type.get_untrusted_value(), config)
         if source is not None:
             schema_data = media_type.media_type_schema
             break
     else:
         return (
-            ParseError(data=data, detail=f"Unsupported content_type {content}"),
+            ParseError(
+                data=data,
+                detail=f"Unsupported content_type {', '.join(key.get_untrusted_value() for key in content)}",
+            ),
             schemas,
         )
 

openapi_python_client/schema/__init__.py

@@ -4,7 +4,6 @@ __all__ = [
     "OpenAPI",
     "Operation",
     "Parameter",
-    "Parameter",
     "ParameterLocation",
     "PathItem",
     "Reference",
@@ -12,6 +11,7 @@ __all__ = [
     "Response",
     "Responses",
     "Schema",
+    "UntrustedString",
 ]
 
 
@@ -29,3 +29,4 @@ from .openapi_schema_pydantic import (
     Schema,
 )
 from .parameter_location import ParameterLocation
+from .untrusted_string import UntrustedString

openapi_python_client/schema/data_type.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from enum import StrEnum
 
 
-class DataType(str, Enum):
+class DataType(StrEnum):
     """The data type of a schema is defined by the type keyword
 
     References:

openapi_python_client/schema/openapi_schema_pydantic/callback.py

@@ -1,11 +1,13 @@
 from typing import TYPE_CHECKING
 
+from ..untrusted_string import UntrustedString
+
 if TYPE_CHECKING:  # pragma: no cover
     from .path_item import PathItem
 else:
     PathItem = "PathItem"
 
-Callback = dict[str, PathItem]
+Callback = dict[UntrustedString, PathItem]
 """
 A map of possible out-of band callbacks related to the parent operation.
 Each value in the map is a [Path Item Object](#pathItemObject)

openapi_python_client/schema/openapi_schema_pydantic/components.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .callback import Callback
 from .example import Example
 from .header import Header
@@ -23,15 +24,15 @@ class Components(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#componentsObject
     """
 
-    schemas: dict[str, ReferenceOr[Schema]] | None = None
-    responses: dict[str, ReferenceOr[Response]] | None = None
-    parameters: dict[str, ReferenceOr[Parameter]] | None = None
-    examples: dict[str, ReferenceOr[Example]] | None = None
-    requestBodies: dict[str, ReferenceOr[RequestBody]] | None = None
-    headers: dict[str, ReferenceOr[Header]] | None = None
-    securitySchemes: dict[str, ReferenceOr[SecurityScheme]] | None = None
-    links: dict[str, ReferenceOr[Link]] | None = None
-    callbacks: dict[str, ReferenceOr[Callback]] | None = None
+    schemas: dict[UntrustedString, ReferenceOr[Schema]] | None = None
+    responses: dict[UntrustedString, ReferenceOr[Response]] | None = None
+    parameters: dict[UntrustedString, ReferenceOr[Parameter]] | None = None
+    examples: dict[UntrustedString, ReferenceOr[Example]] | None = None
+    requestBodies: dict[UntrustedString, ReferenceOr[RequestBody]] | None = None
+    headers: dict[UntrustedString, ReferenceOr[Header]] | None = None
+    securitySchemes: dict[UntrustedString, ReferenceOr[SecurityScheme]] | None = None
+    links: dict[UntrustedString, ReferenceOr[Link]] | None = None
+    callbacks: dict[UntrustedString, ReferenceOr[Callback]] | None = None
     model_config = ConfigDict(
         # `Callback` contains an unresolvable forward reference, will rebuild in `__init__.py`:
         defer_build=True,

openapi_python_client/schema/openapi_schema_pydantic/contact.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from openapi_python_client.schema.untrusted_string import UntrustedString
+
 
 class Contact(BaseModel):
     """
@@ -9,9 +11,9 @@ class Contact(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#contactObject
     """
 
-    name: str | None = None
-    url: str | None = None
-    email: str | None = None
+    name: UntrustedString | None = None
+    url: UntrustedString | None = None
+    email: UntrustedString | None = None
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={

openapi_python_client/schema/openapi_schema_pydantic/discriminator.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
+
 
 class Discriminator(BaseModel):
     """
@@ -16,8 +18,8 @@ class Discriminator(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#discriminatorObject
     """
 
-    propertyName: str
-    mapping: dict[str, str] | None = None
+    propertyName: UntrustedString
+    mapping: dict[UntrustedString, UntrustedString] | None = None
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={

openapi_python_client/schema/openapi_schema_pydantic/encoding.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .reference import ReferenceOr
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -16,9 +17,9 @@ class Encoding(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#encodingObject
     """
 
-    contentType: str | None = None
-    headers: dict[str, ReferenceOr["Header"]] | None = None
-    style: str | None = None
+    contentType: UntrustedString | None = None
+    headers: dict[UntrustedString, ReferenceOr["Header"]] | None = None
+    style: UntrustedString | None = None
     explode: bool = False
     allowReserved: bool = False
     model_config = ConfigDict(

openapi_python_client/schema/openapi_schema_pydantic/example.py

@@ -2,6 +2,8 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
+
 
 class Example(BaseModel):
     """Examples added to parameters / components to help clarify usage.
@@ -11,10 +13,10 @@ class Example(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#exampleObject
     """
 
-    summary: str | None = None
-    description: str | None = None
+    summary: UntrustedString | None = None
+    description: UntrustedString | None = None
     value: Any | None = None
-    externalValue: str | None = None
+    externalValue: UntrustedString | None = None
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={

openapi_python_client/schema/openapi_schema_pydantic/external_documentation.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from openapi_python_client.schema.untrusted_string import UntrustedString
+
 
 class ExternalDocumentation(BaseModel):
     """Allows referencing an external resource for extended documentation.
@@ -8,8 +10,8 @@ class ExternalDocumentation(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#externalDocumentationObject
     """
 
-    description: str | None = None
-    url: str
+    description: UntrustedString | None = None
+    url: UntrustedString
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={"examples": [{"description": "Find more info here", "url": "https://example.com"}]},

openapi_python_client/schema/openapi_schema_pydantic/header.py

@@ -1,10 +1,15 @@
-from pydantic import ConfigDict, Field
+from typing import Any
 
-from ..parameter_location import ParameterLocation
-from .parameter import Parameter
+from pydantic import BaseModel, ConfigDict, Field
 
+from ..untrusted_string import UntrustedString
+from .example import Example
+from .media_type import MediaType
+from .reference import ReferenceOr
+from .schema import Schema
 
-class Header(Parameter):
+
+class Header(BaseModel):
     """
     The Header Object follows the structure of the [Parameter Object](#parameterObject) with the following changes:
 
@@ -18,8 +23,17 @@ class Header(Parameter):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#headerObject
     """
 
-    name: str = Field(default="")
-    param_in: ParameterLocation = Field(default=ParameterLocation.HEADER, alias="in")
+    description: UntrustedString | None = None
+    required: bool = False
+    deprecated: bool = False
+    allowEmptyValue: bool = False
+    style: UntrustedString | None = None
+    explode: bool = False
+    allowReserved: bool = False
+    param_schema: ReferenceOr[Schema] | None = Field(default=None, alias="schema")
+    example: Any | None = None
+    examples: dict[UntrustedString, ReferenceOr[Example]] | None = None
+    content: dict[UntrustedString, MediaType] | None = None
     model_config = ConfigDict(
         # `Parameter` is not build yet, will rebuild in `__init__.py`:
         defer_build=True,

openapi_python_client/schema/openapi_schema_pydantic/info.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .contact import Contact
 from .license import License
 
@@ -15,12 +16,12 @@ class Info(BaseModel):
         -https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#infoObject
     """
 
-    title: str
-    description: str | None = None
-    termsOfService: str | None = None
+    title: UntrustedString
+    description: UntrustedString | None = None
+    termsOfService: UntrustedString | None = None
     contact: Contact | None = None
     license: License | None = None
-    version: str
+    version: UntrustedString
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={

openapi_python_client/schema/openapi_schema_pydantic/license.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
+
 
 class License(BaseModel):
     """
@@ -9,8 +11,8 @@ class License(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#licenseObject
     """
 
-    name: str
-    url: str | None = None
+    name: UntrustedString
+    url: UntrustedString | None = None
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={

openapi_python_client/schema/openapi_schema_pydantic/link.py

@@ -2,6 +2,7 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
 from .server import Server
 
 
@@ -23,11 +24,11 @@ class Link(BaseModel):
         - https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#linkObject
     """
 
-    operationRef: str | None = None
-    operationId: str | None = None
-    parameters: dict[str, Any] | None = None
+    operationRef: UntrustedString | None = None
+    operationId: UntrustedString | None = None
+    parameters: dict[UntrustedString, Any] | None = None
     requestBody: Any | None = None
-    description: str | None = None
+    description: UntrustedString | None = None
     server: Server | None = None
     model_config = ConfigDict(
         extra="allow",

openapi_python_client/schema/openapi_schema_pydantic/media_type.py

@@ -2,6 +2,7 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from ..untrusted_string import UntrustedString
 from .encoding import Encoding
 from .example import Example
 from .reference import ReferenceOr
@@ -18,8 +19,8 @@ class MediaType(BaseModel):
 
     media_type_schema: ReferenceOr[Schema] | None = Field(default=None, alias="schema")
     example: Any | None = None
-    examples: dict[str, ReferenceOr[Example]] | None = None
-    encoding: dict[str, Encoding] | None = None
+    examples: dict[UntrustedString, ReferenceOr[Example]] | None = None
+    encoding: dict[UntrustedString, Encoding] | None = None
     model_config = ConfigDict(
         # `Encoding` is not build yet, will rebuild in `__init__.py`:
         defer_build=True,

openapi_python_client/schema/openapi_schema_pydantic/oauth_flow.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, ConfigDict
 
+from ..untrusted_string import UntrustedString
+
 
 class OAuthFlow(BaseModel):
     """
@@ -10,10 +12,10 @@ class OAuthFlow(BaseModel):
         - https://swagger.io/docs/specification/authentication/oauth2/
     """
 
-    authorizationUrl: str | None = None
-    tokenUrl: str | None = None
-    refreshUrl: str | None = None
-    scopes: dict[str, str]
+    authorizationUrl: UntrustedString | None = None
+    tokenUrl: UntrustedString | None = None
+    refreshUrl: UntrustedString | None = None
+    scopes: dict[UntrustedString, UntrustedString]
     model_config = ConfigDict(
         extra="allow",
         json_schema_extra={