@aws/nx-plugin 1.0.0 → 1.0.2

package/src/open-api/py-client/__snapshots__/generator.petstore.spec.ts.snap

@@ -0,0 +1,3488 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`openApiPyClientGenerator - petstore > should generate valid Python for the full petstore example > async_client.py 1`] = `
+""""AsyncSwaggerPetstoreOpenAPI30 — AUTO-GENERATED asynchronous client."""
+
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypeVar
+from urllib.parse import quote
+
+import httpx
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+from . import types
+from .errors import (
+    AddPetApiError as AddPetApiError,
+)
+from .errors import (
+    ApiError as ApiError,
+)
+from .errors import (
+    CreateUserApiError as CreateUserApiError,
+)
+from .errors import (
+    CreateUsersWithListInputApiError as CreateUsersWithListInputApiError,
+)
+from .errors import (
+    DeleteOrderApiError as DeleteOrderApiError,
+)
+from .errors import (
+    DeletePetApiError as DeletePetApiError,
+)
+from .errors import (
+    DeleteUserApiError as DeleteUserApiError,
+)
+from .errors import (
+    FindPetsByStatusApiError as FindPetsByStatusApiError,
+)
+from .errors import (
+    FindPetsByTagsApiError as FindPetsByTagsApiError,
+)
+from .errors import (
+    GetInventoryApiError as GetInventoryApiError,
+)
+from .errors import (
+    GetOrderByIdApiError as GetOrderByIdApiError,
+)
+from .errors import (
+    GetPetByIdApiError as GetPetByIdApiError,
+)
+from .errors import (
+    GetUserByNameApiError as GetUserByNameApiError,
+)
+from .errors import (
+    LoginUserApiError as LoginUserApiError,
+)
+from .errors import (
+    LogoutUserApiError as LogoutUserApiError,
+)
+from .errors import (
+    PlaceOrderApiError as PlaceOrderApiError,
+)
+from .errors import (
+    UpdatePetApiError as UpdatePetApiError,
+)
+from .errors import (
+    UpdatePetWithFormApiError as UpdatePetWithFormApiError,
+)
+from .errors import (
+    UpdateUserApiError as UpdateUserApiError,
+)
+from .errors import (
+    UploadFileApiError as UploadFileApiError,
+)
+
+_ErrorT = TypeVar("_ErrorT", bound=BaseModel)
+
+
+@dataclass
+class AsyncSwaggerPetstoreOpenAPI30Config:
+    """Client configuration for AsyncSwaggerPetstoreOpenAPI30."""
+
+    #: Base URL for the API.
+    url: str
+    #: Client used for every request. Supply your own to add authentication or
+    #: any other middleware — an \`\`httpx.Auth\`\` (e.g. a SigV4 signer), an event
+    #: hook, a custom transport, timeouts, retries or a proxy all apply, and the
+    #: client's own headers and query params are sent alongside each operation's.
+    #: A supplied client is never closed by this one, so it can be shared.
+    httpx_client: httpx.AsyncClient | None = None
+    #: Headers added to every request, where the operation sets none itself.
+    headers: dict[str, str] = field(default_factory=dict)
+    #: By default the client sends a Content-Type header set to the media type
+    #: the OpenAPI specification declares for the request. Set this to omit it.
+    omit_content_type_header: bool = False
+
+
+class AsyncSwaggerPetstoreOpenAPI30:
+    """Asynchronous API client for SwaggerPetstoreOpenAPI30."""
+
+    def __init__(self, config: AsyncSwaggerPetstoreOpenAPI30Config) -> None:
+        self._config = config
+        self._client = config.httpx_client or httpx.AsyncClient()
+        self._owns_client = config.httpx_client is None
+        self._base_url = config.url.rstrip("/")
+        self.pet: _AsyncPetNamespace = _AsyncPetNamespace(self)
+        self.user: _AsyncUserNamespace = _AsyncUserNamespace(self)
+        self.store: _AsyncStoreNamespace = _AsyncStoreNamespace(self)
+
+    async def __aenter__(self) -> AsyncSwaggerPetstoreOpenAPI30:
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        if self._owns_client:
+            await self._client.aclose()
+
+    def _url(
+        self,
+        path: str,
+        path_params: dict[str, Any],
+        path_styles: dict[str, tuple[str, bool]] | None = None,
+    ) -> str:
+        for key, value in path_params.items():
+            style, explode = (path_styles or {}).get(key, ("simple", False))
+            # An object expands to its key,value members; a list to its items.
+            # Each is encoded on its own so the separators between them stay
+            # literal, as RFC 6570 requires.
+            dumped = self._dump(value)
+            if isinstance(dumped, dict):
+                values = [
+                    part
+                    for k, v in dumped.items()
+                    if v is not None
+                    for part in (k, self._scalar(v))
+                ]
+            elif isinstance(dumped, list):
+                values = list(dumped)
+            else:
+                values = [value]
+            if style == "matrix":
+                # RFC 6570 path-style expansion: ;key=a,b (explode: ;key=a;key=b)
+                if explode:
+                    rendered = "".join(
+                        ";" + key + "=" + quote(self._scalar(v), safe="")
+                        for v in values
+                    )
+                else:
+                    rendered = (
+                        ";"
+                        + key
+                        + "="
+                        + ",".join(quote(self._scalar(v), safe="") for v in values)
+                    )
+            elif style == "label":
+                # RFC 6570 label expansion: .a,b (explode: .a.b)
+                rendered = "." + ("." if explode else ",").join(
+                    quote(self._scalar(v), safe="") for v in values
+                )
+            else:
+                # RFC 6570 simple expansion: a list renders comma-separated.
+                rendered = ",".join(quote(self._scalar(v), safe="") for v in values)
+            path = path.replace("{" + key + "}", rendered)
+        return self._base_url + path
+
+    def _deep_object(self, key: str, value: Any, out: dict[str, Any]) -> None:
+        if isinstance(value, BaseModel):
+            value = value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        if isinstance(value, dict):
+            for prop, v in value.items():
+                self._deep_object(f"{key}[{prop}]", v, out)
+        elif value is not None:
+            out[key] = value
+
+    _COLLECTION_DELIMITERS = {"csv": ",", "ssv": " ", "pipes": "|"}
+
+    #: Characters left literal in a cookie value: every RFC 6265 cookie-octet
+    #: except the \`,\` and \`;\` this client joins members on. A \`=\` stays literal
+    #: too — only the first one separates a cookie's name from its value.
+    _COOKIE_SAFE = "!#$%&'()*+-./:<>?@[]^_\`{|}~="
+
+    def _scalar(self, value: Any) -> str:
+        # The wire form of a single parameter value: JSON spellings for bools,
+        # ISO-8601 for dates, and the model's own wire shape for anything else.
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (datetime.date, datetime.datetime)):
+            return value.isoformat()
+        dumped = self._dump(value)
+        if isinstance(dumped, str):
+            return dumped
+        # RFC 6570 renders a list as its comma-joined members and an object as
+        # comma-joined key,value pairs. Python's own \`str\` would emit a repr —
+        # \`['a', 'b']\`, quotes and spaces included.
+        if isinstance(dumped, list):
+            return ",".join(self._scalar(v) for v in dumped)
+        if isinstance(dumped, dict):
+            return ",".join(
+                f"{k},{self._scalar(v)}" for k, v in dumped.items() if v is not None
+            )
+        if dumped is None:
+            return ""
+        return str(dumped)
+
+    def _query(
+        self,
+        query_params: dict[str, Any],
+        collection_formats: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        out: dict[str, Any] = {}
+        for key, value in query_params.items():
+            if value is None:
+                continue
+            fmt = (collection_formats or {}).get(key)
+            if fmt == "deepObject":
+                self._deep_object(key, value, out)
+            elif isinstance(value, list):
+                delimiter = self._COLLECTION_DELIMITERS.get(fmt or "multi")
+                if delimiter is None:
+                    out[key] = [self._scalar(v) for v in value]
+                else:
+                    out[key] = delimiter.join(self._scalar(v) for v in value)
+            elif self._is_object(value):
+                # OpenAPI's default query style is form/explode, under which an
+                # object expands to one parameter per property rather than
+                # being stringified.
+                for prop, prop_value in self._as_dict(value).items():
+                    if prop_value is not None:
+                        out[prop] = self._scalar(prop_value)
+            else:
+                out[key] = self._scalar(value)
+        return out
+
+    def _is_object(self, value: Any) -> bool:
+        return isinstance(value, (dict, BaseModel))
+
+    def _as_dict(self, value: Any) -> dict[str, Any]:
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        return dict(value)
+
+    def _headers(
+        self,
+        header_params: dict[str, Any] | None = None,
+        collection_formats: dict[str, str] | None = None,
+        cookie_params: dict[str, Any] | None = None,
+    ) -> list[tuple[str, str]]:
+        out: list[tuple[str, str]] = []
+        for key, value in (header_params or {}).items():
+            if value is None:
+                continue
+            if isinstance(value, list):
+                fmt = (collection_formats or {}).get(key, "csv")
+                delimiter = self._COLLECTION_DELIMITERS.get(fmt)
+                if delimiter is None:
+                    for item in value:
+                        out.append((key, self._scalar(item)))
+                else:
+                    out.append((key, delimiter.join(self._scalar(v) for v in value)))
+            else:
+                out.append((key, self._scalar(value)))
+        # A config header only applies where the operation didn't set one:
+        # httpx comma-joins repeated names, which would corrupt the value.
+        operation_headers = {key.lower() for key, _ in out}
+        out.extend(
+            (key, value)
+            for key, value in self._config.headers.items()
+            if key.lower() not in operation_headers
+        )
+        # The operation's cookies are merged into one \`Cookie\` header alongside
+        # every other source. Passing them to httpx's \`cookies=\` instead would
+        # drop them outright whenever a \`Cookie\` header is present, since
+        # http.cookiejar skips a request that already carries one — and setting
+        # the header here would in turn shadow the caller's own jar and header,
+        # which httpx resolves in favour of the more specific value.
+        cookies = self._cookies(cookie_params or {})
+        if cookies:
+            pairs = [
+                *(
+                    value
+                    for source in (self._client.headers, dict(out))
+                    for key, value in source.items()
+                    if key.lower() == "cookie"
+                ),
+                *(f"{key}={value}" for key, value in self._client.cookies.items()),
+                *(f"{key}={value}" for key, value in cookies.items()),
+            ]
+            out = [(key, value) for key, value in out if key.lower() != "cookie"]
+            out.append(("Cookie", "; ".join(pairs)))
+        return out
+
+    def _default_content_type(
+        self, header_params: dict[str, Any], media_type: str
+    ) -> None:
+        # The media type the specification declares, applied unless the operation
+        # takes a Content-Type of its own and the caller supplied one. Header
+        # names are case-insensitive, and a declared header the caller omitted is
+        # present holding \`None\` — neither counts as the caller setting it.
+        if any(
+            key.lower() == "content-type" and value is not None
+            for key, value in header_params.items()
+        ):
+            return
+        for key in list(header_params):
+            if key.lower() == "content-type":
+                header_params[key] = media_type
+                return
+        header_params["Content-Type"] = media_type
+
+    def _cookies(self, cookie_params: dict[str, Any]) -> dict[str, str]:
+        out: dict[str, str] = {}
+        for key, value in cookie_params.items():
+            if value is None:
+                continue
+            dumped = self._dump(value)
+            # A cookie uses form-style expansion, so a list joins on \`,\` and an
+            # object on \`,\` between each key and value. Members are encoded so a
+            # \`;\` or \`,\` inside one can't be read as a delimiter, while the
+            # joining commas stay literal.
+            if isinstance(dumped, list):
+                rendered = ",".join(self._cookie_value(v) for v in dumped)
+            elif isinstance(dumped, dict):
+                rendered = ",".join(
+                    self._cookie_value(k) + "," + self._cookie_value(v)
+                    for k, v in dumped.items()
+                    if v is not None
+                )
+            else:
+                rendered = self._cookie_value(value)
+            out[key] = rendered
+        return out
+
+    def _cookie_value(self, value: Any) -> str:
+        # Only the characters a cookie parser treats as structure are escaped, so
+        # a timestamp keeps its colons and a base64 token its \`=\` padding. Servers
+        # do not URL-decode cookies, so anything escaped here arrives escaped.
+        return quote(self._scalar(value), safe=self._COOKIE_SAFE)
+
+    def _dump(self, value: Any) -> Any:
+        if value is None:
+            return None
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        if isinstance(value, (list, tuple)):
+            return [self._dump(v) for v in value]
+        if isinstance(value, dict):
+            return {k: self._dump(v) for k, v in value.items()}
+        if isinstance(value, (datetime.date, datetime.datetime)):
+            return value.isoformat()
+        return value
+
+    def _json_body(self, response: httpx.Response) -> Any:
+        # A response declaring JSON alongside another media type can arrive as
+        # either, and a declared-JSON body can arrive empty (a 200 with no
+        # content). Both would raise a bare JSONDecodeError out of the client, so
+        # the text is handed over instead.
+        if not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    def _error_payload(self, response: httpx.Response) -> Any:
+        # An error body is whatever the server actually sent, which need not be
+        # the JSON the spec declares (a proxy's HTML page, say).
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    def _error(self, wrapper: type[_ErrorT], status: int, payload: Any) -> _ErrorT:
+        # Coerce to the declared error type, falling back to the raw payload so
+        # a body that doesn't match the spec still raises the typed exception.
+        try:
+            return wrapper.model_validate({"status": status, "error": payload})
+        except ValidationError:
+            return wrapper.model_construct(status=status, error=payload)
+
+    async def _add_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Add a new pet to the store."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        _body_fields["name"] = name
+        _body_fields["photoUrls"] = photo_urls
+        if id is not None:
+            _body_fields["id"] = id
+        if category is not None:
+            _body_fields["category"] = category
+        if tags is not None:
+            _body_fields["tags"] = tags
+        if status is not None:
+            _body_fields["status"] = status
+        body = types.Pet.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/pet", {})
+        response = await self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise AddPetApiError(
+                response.status_code,
+                self._error(types.AddPet400Error, 400, None),
+            )
+        if response.status_code == 422:
+            raise AddPetApiError(
+                response.status_code,
+                self._error(types.AddPet422Error, 422, None),
+            )
+        raise AddPetApiError(
+            response.status_code,
+            self._error(types.AddPetDefaultError, response.status_code, None),
+        )
+
+    async def _create_user(
+        self,
+        *,
+        id: int | None = None,
+        username: str | None = None,
+        first_name: str | None = None,
+        last_name: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        phone: str | None = None,
+        user_status: int | None = None,
+    ) -> types.User:
+        """This can only be done by the logged in user."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        if id is not None:
+            _body_fields["id"] = id
+        if username is not None:
+            _body_fields["username"] = username
+        if first_name is not None:
+            _body_fields["firstName"] = first_name
+        if last_name is not None:
+            _body_fields["lastName"] = last_name
+        if email is not None:
+            _body_fields["email"] = email
+        if password is not None:
+            _body_fields["password"] = password
+        if phone is not None:
+            _body_fields["phone"] = phone
+        if user_status is not None:
+            _body_fields["userStatus"] = user_status
+        body = types.User.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/user", {})
+        response = await self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.User.model_validate(self._json_body(response))
+        raise CreateUserApiError(
+            response.status_code,
+            self._error(types.CreateUserDefaultError, response.status_code, None),
+        )
+
+    async def _create_users_with_list_input(
+        self,
+        body: list[types.User] | None = None,
+    ) -> types.User:
+        """Creates list of users with given input array."""
+        header_params: dict[str, Any] = {}
+        body = self._dump(body)
+        request_kwargs: dict[str, Any] = {"json": body}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/user/createWithList", {})
+        response = await self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.User.model_validate(self._json_body(response))
+        raise CreateUsersWithListInputApiError(
+            response.status_code,
+            self._error(
+                types.CreateUsersWithListInputDefaultError, response.status_code, None
+            ),
+        )
+
+    async def _delete_order(
+        self,
+        *,
+        order_id: int,
+    ) -> None:
+        """
+        For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API
+        errors.
+        """
+        path_params: dict[str, Any] = {"orderId": order_id}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/store/order/{orderId}", path_params)
+        response = await self._client.request(
+            "DELETE",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise DeleteOrderApiError(
+                response.status_code,
+                self._error(types.DeleteOrder400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise DeleteOrderApiError(
+                response.status_code,
+                self._error(types.DeleteOrder404Error, 404, None),
+            )
+        raise DeleteOrderApiError(
+            response.status_code,
+            self._error(types.DeleteOrderDefaultError, response.status_code, None),
+        )
+
+    async def _delete_pet(
+        self,
+        *,
+        pet_id: int,
+        api_key: str | None = None,
+    ) -> None:
+        """Delete a pet."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        header_params: dict[str, Any] = {"api_key": api_key}
+        header_formats: dict[str, str] | None = {"api_key": "csv"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/{petId}", path_params)
+        response = await self._client.request(
+            "DELETE",
+            _request_url,
+            headers=self._headers(header_params, collection_formats=header_formats),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise DeletePetApiError(
+                response.status_code,
+                self._error(types.DeletePet400Error, 400, None),
+            )
+        raise DeletePetApiError(
+            response.status_code,
+            self._error(types.DeletePetDefaultError, response.status_code, None),
+        )
+
+    async def _delete_user(
+        self,
+        *,
+        username: str,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        path_params: dict[str, Any] = {"username": username}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/{username}", path_params)
+        response = await self._client.request(
+            "DELETE",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise DeleteUserApiError(
+                response.status_code,
+                self._error(types.DeleteUser400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise DeleteUserApiError(
+                response.status_code,
+                self._error(types.DeleteUser404Error, 404, None),
+            )
+        raise DeleteUserApiError(
+            response.status_code,
+            self._error(types.DeleteUserDefaultError, response.status_code, None),
+        )
+
+    async def _find_pets_by_status(
+        self,
+        *,
+        status: Literal["available", "pending", "sold"] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple status values can be provided with comma separated strings."""
+        query_params: dict[str, Any] = {"status": status}
+        query_formats: dict[str, str] | None = {"status": "multi"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/findByStatus", {})
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return TypeAdapter(list[types.Pet]).validate_python(
+                self._json_body(response)
+            )
+        if response.status_code == 400:
+            raise FindPetsByStatusApiError(
+                response.status_code,
+                self._error(types.FindPetsByStatus400Error, 400, None),
+            )
+        raise FindPetsByStatusApiError(
+            response.status_code,
+            self._error(types.FindPetsByStatusDefaultError, response.status_code, None),
+        )
+
+    async def _find_pets_by_tags(
+        self,
+        *,
+        tags: list[str] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing."""
+        query_params: dict[str, Any] = {"tags": tags}
+        query_formats: dict[str, str] | None = {"tags": "multi"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/findByTags", {})
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return TypeAdapter(list[types.Pet]).validate_python(
+                self._json_body(response)
+            )
+        if response.status_code == 400:
+            raise FindPetsByTagsApiError(
+                response.status_code,
+                self._error(types.FindPetsByTags400Error, 400, None),
+            )
+        raise FindPetsByTagsApiError(
+            response.status_code,
+            self._error(types.FindPetsByTagsDefaultError, response.status_code, None),
+        )
+
+    async def _get_inventory(
+        self,
+    ) -> types.GetInventory200Response:
+        """Returns a map of status codes to quantities."""
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/store/inventory", {})
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return TypeAdapter(types.GetInventory200Response).validate_python(
+                response.json()
+            )
+        raise GetInventoryApiError(
+            response.status_code,
+            self._error(types.GetInventoryDefaultError, response.status_code, None),
+        )
+
+    async def _get_order_by_id(
+        self,
+        *,
+        order_id: int,
+    ) -> types.Order:
+        """For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions."""
+        path_params: dict[str, Any] = {"orderId": order_id}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/store/order/{orderId}", path_params)
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Order.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise GetOrderByIdApiError(
+                response.status_code,
+                self._error(types.GetOrderById400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise GetOrderByIdApiError(
+                response.status_code,
+                self._error(types.GetOrderById404Error, 404, None),
+            )
+        raise GetOrderByIdApiError(
+            response.status_code,
+            self._error(types.GetOrderByIdDefaultError, response.status_code, None),
+        )
+
+    async def _get_pet_by_id(
+        self,
+        *,
+        pet_id: int,
+    ) -> types.Pet:
+        """Returns a single pet."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/{petId}", path_params)
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise GetPetByIdApiError(
+                response.status_code,
+                self._error(types.GetPetById400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise GetPetByIdApiError(
+                response.status_code,
+                self._error(types.GetPetById404Error, 404, None),
+            )
+        raise GetPetByIdApiError(
+            response.status_code,
+            self._error(types.GetPetByIdDefaultError, response.status_code, None),
+        )
+
+    async def _get_user_by_name(
+        self,
+        *,
+        username: str,
+    ) -> types.User:
+        """Get user detail based on username."""
+        path_params: dict[str, Any] = {"username": username}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/{username}", path_params)
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.User.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise GetUserByNameApiError(
+                response.status_code,
+                self._error(types.GetUserByName400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise GetUserByNameApiError(
+                response.status_code,
+                self._error(types.GetUserByName404Error, 404, None),
+            )
+        raise GetUserByNameApiError(
+            response.status_code,
+            self._error(types.GetUserByNameDefaultError, response.status_code, None),
+        )
+
+    async def _login_user(
+        self,
+        *,
+        username: str | None = None,
+        password: str | None = None,
+    ) -> str:
+        """Log into the system."""
+        query_params: dict[str, Any] = {"username": username, "password": password}
+        query_formats: dict[str, str] | None = {
+            "username": "multi",
+            "password": "multi",
+        }
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/login", {})
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return self._json_body(response)
+        if response.status_code == 400:
+            raise LoginUserApiError(
+                response.status_code,
+                self._error(types.LoginUser400Error, 400, None),
+            )
+        raise LoginUserApiError(
+            response.status_code,
+            self._error(types.LoginUserDefaultError, response.status_code, None),
+        )
+
+    async def _logout_user(
+        self,
+    ) -> None:
+        """Log user out of the system."""
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/logout", {})
+        response = await self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        raise LogoutUserApiError(
+            response.status_code,
+            self._error(types.LogoutUserDefaultError, response.status_code, None),
+        )
+
+    async def _place_order(
+        self,
+        *,
+        id: int | None = None,
+        pet_id: int | None = None,
+        quantity: int | None = None,
+        ship_date: datetime.datetime | None = None,
+        status: types.OrderStatus | None = None,
+        complete: bool | None = None,
+    ) -> types.Order:
+        """Place a new order in the store."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        if id is not None:
+            _body_fields["id"] = id
+        if pet_id is not None:
+            _body_fields["petId"] = pet_id
+        if quantity is not None:
+            _body_fields["quantity"] = quantity
+        if ship_date is not None:
+            _body_fields["shipDate"] = ship_date
+        if status is not None:
+            _body_fields["status"] = status
+        if complete is not None:
+            _body_fields["complete"] = complete
+        body = types.Order.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/store/order", {})
+        response = await self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Order.model_validate(response.json())
+        if response.status_code == 400:
+            raise PlaceOrderApiError(
+                response.status_code,
+                self._error(types.PlaceOrder400Error, 400, None),
+            )
+        if response.status_code == 422:
+            raise PlaceOrderApiError(
+                response.status_code,
+                self._error(types.PlaceOrder422Error, 422, None),
+            )
+        raise PlaceOrderApiError(
+            response.status_code,
+            self._error(types.PlaceOrderDefaultError, response.status_code, None),
+        )
+
+    async def _update_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Update an existing pet by Id."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        _body_fields["name"] = name
+        _body_fields["photoUrls"] = photo_urls
+        if id is not None:
+            _body_fields["id"] = id
+        if category is not None:
+            _body_fields["category"] = category
+        if tags is not None:
+            _body_fields["tags"] = tags
+        if status is not None:
+            _body_fields["status"] = status
+        body = types.Pet.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/pet", {})
+        response = await self._client.request(
+            "PUT",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise UpdatePetApiError(
+                response.status_code,
+                self._error(types.UpdatePet400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise UpdatePetApiError(
+                response.status_code,
+                self._error(types.UpdatePet404Error, 404, None),
+            )
+        if response.status_code == 422:
+            raise UpdatePetApiError(
+                response.status_code,
+                self._error(types.UpdatePet422Error, 422, None),
+            )
+        raise UpdatePetApiError(
+            response.status_code,
+            self._error(types.UpdatePetDefaultError, response.status_code, None),
+        )
+
+    async def _update_pet_with_form(
+        self,
+        *,
+        pet_id: int,
+        name: str | None = None,
+        status: str | None = None,
+    ) -> types.Pet:
+        """Updates a pet resource based on the form data."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        query_params: dict[str, Any] = {"name": name, "status": status}
+        query_formats: dict[str, str] | None = {"name": "multi", "status": "multi"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/{petId}", path_params)
+        response = await self._client.request(
+            "POST",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise UpdatePetWithFormApiError(
+                response.status_code,
+                self._error(types.UpdatePetWithForm400Error, 400, None),
+            )
+        raise UpdatePetWithFormApiError(
+            response.status_code,
+            self._error(
+                types.UpdatePetWithFormDefaultError, response.status_code, None
+            ),
+        )
+
+    async def _update_user(
+        self,
+        *,
+        username: str,
+        body: types.User | None = None,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        path_params: dict[str, Any] = {"username": username}
+        header_params: dict[str, Any] = {}
+        body = self._dump(body)
+        request_kwargs: dict[str, Any] = {"json": body}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/user/{username}", path_params)
+        response = await self._client.request(
+            "PUT",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise UpdateUserApiError(
+                response.status_code,
+                self._error(types.UpdateUser400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise UpdateUserApiError(
+                response.status_code,
+                self._error(types.UpdateUser404Error, 404, None),
+            )
+        raise UpdateUserApiError(
+            response.status_code,
+            self._error(types.UpdateUserDefaultError, response.status_code, None),
+        )
+
+    async def _upload_file(
+        self,
+        *,
+        pet_id: int,
+        additional_metadata: str | None = None,
+        body: bytes | None = None,
+    ) -> types.ApiResponse:
+        """Upload image of the pet."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        query_params: dict[str, Any] = {"additionalMetadata": additional_metadata}
+        header_params: dict[str, Any] = {}
+        query_formats: dict[str, str] | None = {"additionalMetadata": "multi"}
+        body = body
+        request_kwargs: dict[str, Any] = {"content": body}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/octet-stream")
+        _request_url = self._url("/pet/{petId}/uploadImage", path_params)
+        response = await self._client.request(
+            "POST",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.ApiResponse.model_validate(response.json())
+        if response.status_code == 400:
+            raise UploadFileApiError(
+                response.status_code,
+                self._error(types.UploadFile400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise UploadFileApiError(
+                response.status_code,
+                self._error(types.UploadFile404Error, 404, None),
+            )
+        raise UploadFileApiError(
+            response.status_code,
+            self._error(types.UploadFileDefaultError, response.status_code, None),
+        )
+
+
+class _AsyncPetNamespace:
+    """\`pet\` operations."""
+
+    def __init__(self, parent: AsyncSwaggerPetstoreOpenAPI30) -> None:
+        self._parent = parent
+
+    async def add_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Add a new pet to the store."""
+        return await self._parent._add_pet(
+            name=name,
+            photo_urls=photo_urls,
+            id=id,
+            category=category,
+            tags=tags,
+            status=status,
+        )
+
+    async def delete_pet(
+        self,
+        *,
+        pet_id: int,
+        api_key: str | None = None,
+    ) -> None:
+        """Delete a pet."""
+        return await self._parent._delete_pet(
+            pet_id=pet_id,
+            api_key=api_key,
+        )
+
+    async def find_pets_by_status(
+        self,
+        *,
+        status: Literal["available", "pending", "sold"] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple status values can be provided with comma separated strings."""
+        return await self._parent._find_pets_by_status(
+            status=status,
+        )
+
+    async def find_pets_by_tags(
+        self,
+        *,
+        tags: list[str] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing."""
+        return await self._parent._find_pets_by_tags(
+            tags=tags,
+        )
+
+    async def get_pet_by_id(
+        self,
+        *,
+        pet_id: int,
+    ) -> types.Pet:
+        """Returns a single pet."""
+        return await self._parent._get_pet_by_id(
+            pet_id=pet_id,
+        )
+
+    async def update_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Update an existing pet by Id."""
+        return await self._parent._update_pet(
+            name=name,
+            photo_urls=photo_urls,
+            id=id,
+            category=category,
+            tags=tags,
+            status=status,
+        )
+
+    async def update_pet_with_form(
+        self,
+        *,
+        pet_id: int,
+        name: str | None = None,
+        status: str | None = None,
+    ) -> types.Pet:
+        """Updates a pet resource based on the form data."""
+        return await self._parent._update_pet_with_form(
+            pet_id=pet_id,
+            name=name,
+            status=status,
+        )
+
+    async def upload_file(
+        self,
+        *,
+        pet_id: int,
+        additional_metadata: str | None = None,
+        body: bytes | None = None,
+    ) -> types.ApiResponse:
+        """Upload image of the pet."""
+        return await self._parent._upload_file(
+            pet_id=pet_id,
+            additional_metadata=additional_metadata,
+            body=body,
+        )
+
+
+class _AsyncUserNamespace:
+    """\`user\` operations."""
+
+    def __init__(self, parent: AsyncSwaggerPetstoreOpenAPI30) -> None:
+        self._parent = parent
+
+    async def create_user(
+        self,
+        *,
+        id: int | None = None,
+        username: str | None = None,
+        first_name: str | None = None,
+        last_name: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        phone: str | None = None,
+        user_status: int | None = None,
+    ) -> types.User:
+        """This can only be done by the logged in user."""
+        return await self._parent._create_user(
+            id=id,
+            username=username,
+            first_name=first_name,
+            last_name=last_name,
+            email=email,
+            password=password,
+            phone=phone,
+            user_status=user_status,
+        )
+
+    async def create_users_with_list_input(
+        self,
+        body: list[types.User] | None = None,
+    ) -> types.User:
+        """Creates list of users with given input array."""
+        return await self._parent._create_users_with_list_input(
+            body,
+        )
+
+    async def delete_user(
+        self,
+        *,
+        username: str,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        return await self._parent._delete_user(
+            username=username,
+        )
+
+    async def get_user_by_name(
+        self,
+        *,
+        username: str,
+    ) -> types.User:
+        """Get user detail based on username."""
+        return await self._parent._get_user_by_name(
+            username=username,
+        )
+
+    async def login_user(
+        self,
+        *,
+        username: str | None = None,
+        password: str | None = None,
+    ) -> str:
+        """Log into the system."""
+        return await self._parent._login_user(
+            username=username,
+            password=password,
+        )
+
+    async def logout_user(
+        self,
+    ) -> None:
+        """Log user out of the system."""
+        return await self._parent._logout_user()
+
+    async def update_user(
+        self,
+        *,
+        username: str,
+        body: types.User | None = None,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        return await self._parent._update_user(
+            username=username,
+            body=body,
+        )
+
+
+class _AsyncStoreNamespace:
+    """\`store\` operations."""
+
+    def __init__(self, parent: AsyncSwaggerPetstoreOpenAPI30) -> None:
+        self._parent = parent
+
+    async def delete_order(
+        self,
+        *,
+        order_id: int,
+    ) -> None:
+        """
+        For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API
+        errors.
+        """
+        return await self._parent._delete_order(
+            order_id=order_id,
+        )
+
+    async def get_inventory(
+        self,
+    ) -> types.GetInventory200Response:
+        """Returns a map of status codes to quantities."""
+        return await self._parent._get_inventory()
+
+    async def get_order_by_id(
+        self,
+        *,
+        order_id: int,
+    ) -> types.Order:
+        """For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions."""
+        return await self._parent._get_order_by_id(
+            order_id=order_id,
+        )
+
+    async def place_order(
+        self,
+        *,
+        id: int | None = None,
+        pet_id: int | None = None,
+        quantity: int | None = None,
+        ship_date: datetime.datetime | None = None,
+        status: types.OrderStatus | None = None,
+        complete: bool | None = None,
+    ) -> types.Order:
+        """Place a new order in the store."""
+        return await self._parent._place_order(
+            id=id,
+            pet_id=pet_id,
+            quantity=quantity,
+            ship_date=ship_date,
+            status=status,
+            complete=complete,
+        )
+"
+`;
+
+exports[`openApiPyClientGenerator - petstore > should generate valid Python for the full petstore example > client.py 1`] = `
+""""SwaggerPetstoreOpenAPI30 — AUTO-GENERATED synchronous client."""
+
+from __future__ import annotations
+
+import datetime
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypeVar
+from urllib.parse import quote
+
+import httpx
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+from . import types
+from .errors import (
+    AddPetApiError as AddPetApiError,
+)
+from .errors import (
+    ApiError as ApiError,
+)
+from .errors import (
+    CreateUserApiError as CreateUserApiError,
+)
+from .errors import (
+    CreateUsersWithListInputApiError as CreateUsersWithListInputApiError,
+)
+from .errors import (
+    DeleteOrderApiError as DeleteOrderApiError,
+)
+from .errors import (
+    DeletePetApiError as DeletePetApiError,
+)
+from .errors import (
+    DeleteUserApiError as DeleteUserApiError,
+)
+from .errors import (
+    FindPetsByStatusApiError as FindPetsByStatusApiError,
+)
+from .errors import (
+    FindPetsByTagsApiError as FindPetsByTagsApiError,
+)
+from .errors import (
+    GetInventoryApiError as GetInventoryApiError,
+)
+from .errors import (
+    GetOrderByIdApiError as GetOrderByIdApiError,
+)
+from .errors import (
+    GetPetByIdApiError as GetPetByIdApiError,
+)
+from .errors import (
+    GetUserByNameApiError as GetUserByNameApiError,
+)
+from .errors import (
+    LoginUserApiError as LoginUserApiError,
+)
+from .errors import (
+    LogoutUserApiError as LogoutUserApiError,
+)
+from .errors import (
+    PlaceOrderApiError as PlaceOrderApiError,
+)
+from .errors import (
+    UpdatePetApiError as UpdatePetApiError,
+)
+from .errors import (
+    UpdatePetWithFormApiError as UpdatePetWithFormApiError,
+)
+from .errors import (
+    UpdateUserApiError as UpdateUserApiError,
+)
+from .errors import (
+    UploadFileApiError as UploadFileApiError,
+)
+
+_ErrorT = TypeVar("_ErrorT", bound=BaseModel)
+
+
+@dataclass
+class SwaggerPetstoreOpenAPI30Config:
+    """Client configuration for SwaggerPetstoreOpenAPI30."""
+
+    #: Base URL for the API.
+    url: str
+    #: Client used for every request. Supply your own to add authentication or
+    #: any other middleware — an \`\`httpx.Auth\`\` (e.g. a SigV4 signer), an event
+    #: hook, a custom transport, timeouts, retries or a proxy all apply, and the
+    #: client's own headers and query params are sent alongside each operation's.
+    #: A supplied client is never closed by this one, so it can be shared.
+    httpx_client: httpx.Client | None = None
+    #: Headers added to every request, where the operation sets none itself.
+    headers: dict[str, str] = field(default_factory=dict)
+    #: By default the client sends a Content-Type header set to the media type
+    #: the OpenAPI specification declares for the request. Set this to omit it.
+    omit_content_type_header: bool = False
+
+
+class SwaggerPetstoreOpenAPI30:
+    """Synchronous API client for SwaggerPetstoreOpenAPI30."""
+
+    def __init__(self, config: SwaggerPetstoreOpenAPI30Config) -> None:
+        self._config = config
+        self._client = config.httpx_client or httpx.Client()
+        self._owns_client = config.httpx_client is None
+        self._base_url = config.url.rstrip("/")
+        self.pet: _PetNamespace = _PetNamespace(self)
+        self.user: _UserNamespace = _UserNamespace(self)
+        self.store: _StoreNamespace = _StoreNamespace(self)
+
+    def __enter__(self) -> SwaggerPetstoreOpenAPI30:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def _url(
+        self,
+        path: str,
+        path_params: dict[str, Any],
+        path_styles: dict[str, tuple[str, bool]] | None = None,
+    ) -> str:
+        for key, value in path_params.items():
+            style, explode = (path_styles or {}).get(key, ("simple", False))
+            # An object expands to its key,value members; a list to its items.
+            # Each is encoded on its own so the separators between them stay
+            # literal, as RFC 6570 requires.
+            dumped = self._dump(value)
+            if isinstance(dumped, dict):
+                values = [
+                    part
+                    for k, v in dumped.items()
+                    if v is not None
+                    for part in (k, self._scalar(v))
+                ]
+            elif isinstance(dumped, list):
+                values = list(dumped)
+            else:
+                values = [value]
+            if style == "matrix":
+                # RFC 6570 path-style expansion: ;key=a,b (explode: ;key=a;key=b)
+                if explode:
+                    rendered = "".join(
+                        ";" + key + "=" + quote(self._scalar(v), safe="")
+                        for v in values
+                    )
+                else:
+                    rendered = (
+                        ";"
+                        + key
+                        + "="
+                        + ",".join(quote(self._scalar(v), safe="") for v in values)
+                    )
+            elif style == "label":
+                # RFC 6570 label expansion: .a,b (explode: .a.b)
+                rendered = "." + ("." if explode else ",").join(
+                    quote(self._scalar(v), safe="") for v in values
+                )
+            else:
+                # RFC 6570 simple expansion: a list renders comma-separated.
+                rendered = ",".join(quote(self._scalar(v), safe="") for v in values)
+            path = path.replace("{" + key + "}", rendered)
+        return self._base_url + path
+
+    def _deep_object(self, key: str, value: Any, out: dict[str, Any]) -> None:
+        if isinstance(value, BaseModel):
+            value = value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        if isinstance(value, dict):
+            for prop, v in value.items():
+                self._deep_object(f"{key}[{prop}]", v, out)
+        elif value is not None:
+            out[key] = value
+
+    _COLLECTION_DELIMITERS = {"csv": ",", "ssv": " ", "pipes": "|"}
+
+    #: Characters left literal in a cookie value: every RFC 6265 cookie-octet
+    #: except the \`,\` and \`;\` this client joins members on. A \`=\` stays literal
+    #: too — only the first one separates a cookie's name from its value.
+    _COOKIE_SAFE = "!#$%&'()*+-./:<>?@[]^_\`{|}~="
+
+    def _scalar(self, value: Any) -> str:
+        # The wire form of a single parameter value: JSON spellings for bools,
+        # ISO-8601 for dates, and the model's own wire shape for anything else.
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (datetime.date, datetime.datetime)):
+            return value.isoformat()
+        dumped = self._dump(value)
+        if isinstance(dumped, str):
+            return dumped
+        # RFC 6570 renders a list as its comma-joined members and an object as
+        # comma-joined key,value pairs. Python's own \`str\` would emit a repr —
+        # \`['a', 'b']\`, quotes and spaces included.
+        if isinstance(dumped, list):
+            return ",".join(self._scalar(v) for v in dumped)
+        if isinstance(dumped, dict):
+            return ",".join(
+                f"{k},{self._scalar(v)}" for k, v in dumped.items() if v is not None
+            )
+        if dumped is None:
+            return ""
+        return str(dumped)
+
+    def _query(
+        self,
+        query_params: dict[str, Any],
+        collection_formats: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        out: dict[str, Any] = {}
+        for key, value in query_params.items():
+            if value is None:
+                continue
+            fmt = (collection_formats or {}).get(key)
+            if fmt == "deepObject":
+                self._deep_object(key, value, out)
+            elif isinstance(value, list):
+                delimiter = self._COLLECTION_DELIMITERS.get(fmt or "multi")
+                if delimiter is None:
+                    out[key] = [self._scalar(v) for v in value]
+                else:
+                    out[key] = delimiter.join(self._scalar(v) for v in value)
+            elif self._is_object(value):
+                # OpenAPI's default query style is form/explode, under which an
+                # object expands to one parameter per property rather than
+                # being stringified.
+                for prop, prop_value in self._as_dict(value).items():
+                    if prop_value is not None:
+                        out[prop] = self._scalar(prop_value)
+            else:
+                out[key] = self._scalar(value)
+        return out
+
+    def _is_object(self, value: Any) -> bool:
+        return isinstance(value, (dict, BaseModel))
+
+    def _as_dict(self, value: Any) -> dict[str, Any]:
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        return dict(value)
+
+    def _headers(
+        self,
+        header_params: dict[str, Any] | None = None,
+        collection_formats: dict[str, str] | None = None,
+        cookie_params: dict[str, Any] | None = None,
+    ) -> list[tuple[str, str]]:
+        out: list[tuple[str, str]] = []
+        for key, value in (header_params or {}).items():
+            if value is None:
+                continue
+            if isinstance(value, list):
+                fmt = (collection_formats or {}).get(key, "csv")
+                delimiter = self._COLLECTION_DELIMITERS.get(fmt)
+                if delimiter is None:
+                    for item in value:
+                        out.append((key, self._scalar(item)))
+                else:
+                    out.append((key, delimiter.join(self._scalar(v) for v in value)))
+            else:
+                out.append((key, self._scalar(value)))
+        # A config header only applies where the operation didn't set one:
+        # httpx comma-joins repeated names, which would corrupt the value.
+        operation_headers = {key.lower() for key, _ in out}
+        out.extend(
+            (key, value)
+            for key, value in self._config.headers.items()
+            if key.lower() not in operation_headers
+        )
+        # The operation's cookies are merged into one \`Cookie\` header alongside
+        # every other source. Passing them to httpx's \`cookies=\` instead would
+        # drop them outright whenever a \`Cookie\` header is present, since
+        # http.cookiejar skips a request that already carries one — and setting
+        # the header here would in turn shadow the caller's own jar and header,
+        # which httpx resolves in favour of the more specific value.
+        cookies = self._cookies(cookie_params or {})
+        if cookies:
+            pairs = [
+                *(
+                    value
+                    for source in (self._client.headers, dict(out))
+                    for key, value in source.items()
+                    if key.lower() == "cookie"
+                ),
+                *(f"{key}={value}" for key, value in self._client.cookies.items()),
+                *(f"{key}={value}" for key, value in cookies.items()),
+            ]
+            out = [(key, value) for key, value in out if key.lower() != "cookie"]
+            out.append(("Cookie", "; ".join(pairs)))
+        return out
+
+    def _default_content_type(
+        self, header_params: dict[str, Any], media_type: str
+    ) -> None:
+        # The media type the specification declares, applied unless the operation
+        # takes a Content-Type of its own and the caller supplied one. Header
+        # names are case-insensitive, and a declared header the caller omitted is
+        # present holding \`None\` — neither counts as the caller setting it.
+        if any(
+            key.lower() == "content-type" and value is not None
+            for key, value in header_params.items()
+        ):
+            return
+        for key in list(header_params):
+            if key.lower() == "content-type":
+                header_params[key] = media_type
+                return
+        header_params["Content-Type"] = media_type
+
+    def _cookies(self, cookie_params: dict[str, Any]) -> dict[str, str]:
+        out: dict[str, str] = {}
+        for key, value in cookie_params.items():
+            if value is None:
+                continue
+            dumped = self._dump(value)
+            # A cookie uses form-style expansion, so a list joins on \`,\` and an
+            # object on \`,\` between each key and value. Members are encoded so a
+            # \`;\` or \`,\` inside one can't be read as a delimiter, while the
+            # joining commas stay literal.
+            if isinstance(dumped, list):
+                rendered = ",".join(self._cookie_value(v) for v in dumped)
+            elif isinstance(dumped, dict):
+                rendered = ",".join(
+                    self._cookie_value(k) + "," + self._cookie_value(v)
+                    for k, v in dumped.items()
+                    if v is not None
+                )
+            else:
+                rendered = self._cookie_value(value)
+            out[key] = rendered
+        return out
+
+    def _cookie_value(self, value: Any) -> str:
+        # Only the characters a cookie parser treats as structure are escaped, so
+        # a timestamp keeps its colons and a base64 token its \`=\` padding. Servers
+        # do not URL-decode cookies, so anything escaped here arrives escaped.
+        return quote(self._scalar(value), safe=self._COOKIE_SAFE)
+
+    def _dump(self, value: Any) -> Any:
+        if value is None:
+            return None
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        if isinstance(value, (list, tuple)):
+            return [self._dump(v) for v in value]
+        if isinstance(value, dict):
+            return {k: self._dump(v) for k, v in value.items()}
+        if isinstance(value, (datetime.date, datetime.datetime)):
+            return value.isoformat()
+        return value
+
+    def _json_body(self, response: httpx.Response) -> Any:
+        # A response declaring JSON alongside another media type can arrive as
+        # either, and a declared-JSON body can arrive empty (a 200 with no
+        # content). Both would raise a bare JSONDecodeError out of the client, so
+        # the text is handed over instead.
+        if not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    def _error_payload(self, response: httpx.Response) -> Any:
+        # An error body is whatever the server actually sent, which need not be
+        # the JSON the spec declares (a proxy's HTML page, say).
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    def _error(self, wrapper: type[_ErrorT], status: int, payload: Any) -> _ErrorT:
+        # Coerce to the declared error type, falling back to the raw payload so
+        # a body that doesn't match the spec still raises the typed exception.
+        try:
+            return wrapper.model_validate({"status": status, "error": payload})
+        except ValidationError:
+            return wrapper.model_construct(status=status, error=payload)
+
+    def _add_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Add a new pet to the store."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        _body_fields["name"] = name
+        _body_fields["photoUrls"] = photo_urls
+        if id is not None:
+            _body_fields["id"] = id
+        if category is not None:
+            _body_fields["category"] = category
+        if tags is not None:
+            _body_fields["tags"] = tags
+        if status is not None:
+            _body_fields["status"] = status
+        body = types.Pet.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/pet", {})
+        response = self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise AddPetApiError(
+                response.status_code,
+                self._error(types.AddPet400Error, 400, None),
+            )
+        if response.status_code == 422:
+            raise AddPetApiError(
+                response.status_code,
+                self._error(types.AddPet422Error, 422, None),
+            )
+        raise AddPetApiError(
+            response.status_code,
+            self._error(types.AddPetDefaultError, response.status_code, None),
+        )
+
+    def _create_user(
+        self,
+        *,
+        id: int | None = None,
+        username: str | None = None,
+        first_name: str | None = None,
+        last_name: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        phone: str | None = None,
+        user_status: int | None = None,
+    ) -> types.User:
+        """This can only be done by the logged in user."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        if id is not None:
+            _body_fields["id"] = id
+        if username is not None:
+            _body_fields["username"] = username
+        if first_name is not None:
+            _body_fields["firstName"] = first_name
+        if last_name is not None:
+            _body_fields["lastName"] = last_name
+        if email is not None:
+            _body_fields["email"] = email
+        if password is not None:
+            _body_fields["password"] = password
+        if phone is not None:
+            _body_fields["phone"] = phone
+        if user_status is not None:
+            _body_fields["userStatus"] = user_status
+        body = types.User.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/user", {})
+        response = self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.User.model_validate(self._json_body(response))
+        raise CreateUserApiError(
+            response.status_code,
+            self._error(types.CreateUserDefaultError, response.status_code, None),
+        )
+
+    def _create_users_with_list_input(
+        self,
+        body: list[types.User] | None = None,
+    ) -> types.User:
+        """Creates list of users with given input array."""
+        header_params: dict[str, Any] = {}
+        body = self._dump(body)
+        request_kwargs: dict[str, Any] = {"json": body}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/user/createWithList", {})
+        response = self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.User.model_validate(self._json_body(response))
+        raise CreateUsersWithListInputApiError(
+            response.status_code,
+            self._error(
+                types.CreateUsersWithListInputDefaultError, response.status_code, None
+            ),
+        )
+
+    def _delete_order(
+        self,
+        *,
+        order_id: int,
+    ) -> None:
+        """
+        For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API
+        errors.
+        """
+        path_params: dict[str, Any] = {"orderId": order_id}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/store/order/{orderId}", path_params)
+        response = self._client.request(
+            "DELETE",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise DeleteOrderApiError(
+                response.status_code,
+                self._error(types.DeleteOrder400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise DeleteOrderApiError(
+                response.status_code,
+                self._error(types.DeleteOrder404Error, 404, None),
+            )
+        raise DeleteOrderApiError(
+            response.status_code,
+            self._error(types.DeleteOrderDefaultError, response.status_code, None),
+        )
+
+    def _delete_pet(
+        self,
+        *,
+        pet_id: int,
+        api_key: str | None = None,
+    ) -> None:
+        """Delete a pet."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        header_params: dict[str, Any] = {"api_key": api_key}
+        header_formats: dict[str, str] | None = {"api_key": "csv"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/{petId}", path_params)
+        response = self._client.request(
+            "DELETE",
+            _request_url,
+            headers=self._headers(header_params, collection_formats=header_formats),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise DeletePetApiError(
+                response.status_code,
+                self._error(types.DeletePet400Error, 400, None),
+            )
+        raise DeletePetApiError(
+            response.status_code,
+            self._error(types.DeletePetDefaultError, response.status_code, None),
+        )
+
+    def _delete_user(
+        self,
+        *,
+        username: str,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        path_params: dict[str, Any] = {"username": username}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/{username}", path_params)
+        response = self._client.request(
+            "DELETE",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise DeleteUserApiError(
+                response.status_code,
+                self._error(types.DeleteUser400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise DeleteUserApiError(
+                response.status_code,
+                self._error(types.DeleteUser404Error, 404, None),
+            )
+        raise DeleteUserApiError(
+            response.status_code,
+            self._error(types.DeleteUserDefaultError, response.status_code, None),
+        )
+
+    def _find_pets_by_status(
+        self,
+        *,
+        status: Literal["available", "pending", "sold"] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple status values can be provided with comma separated strings."""
+        query_params: dict[str, Any] = {"status": status}
+        query_formats: dict[str, str] | None = {"status": "multi"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/findByStatus", {})
+        response = self._client.request(
+            "GET",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return TypeAdapter(list[types.Pet]).validate_python(
+                self._json_body(response)
+            )
+        if response.status_code == 400:
+            raise FindPetsByStatusApiError(
+                response.status_code,
+                self._error(types.FindPetsByStatus400Error, 400, None),
+            )
+        raise FindPetsByStatusApiError(
+            response.status_code,
+            self._error(types.FindPetsByStatusDefaultError, response.status_code, None),
+        )
+
+    def _find_pets_by_tags(
+        self,
+        *,
+        tags: list[str] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing."""
+        query_params: dict[str, Any] = {"tags": tags}
+        query_formats: dict[str, str] | None = {"tags": "multi"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/findByTags", {})
+        response = self._client.request(
+            "GET",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return TypeAdapter(list[types.Pet]).validate_python(
+                self._json_body(response)
+            )
+        if response.status_code == 400:
+            raise FindPetsByTagsApiError(
+                response.status_code,
+                self._error(types.FindPetsByTags400Error, 400, None),
+            )
+        raise FindPetsByTagsApiError(
+            response.status_code,
+            self._error(types.FindPetsByTagsDefaultError, response.status_code, None),
+        )
+
+    def _get_inventory(
+        self,
+    ) -> types.GetInventory200Response:
+        """Returns a map of status codes to quantities."""
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/store/inventory", {})
+        response = self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return TypeAdapter(types.GetInventory200Response).validate_python(
+                response.json()
+            )
+        raise GetInventoryApiError(
+            response.status_code,
+            self._error(types.GetInventoryDefaultError, response.status_code, None),
+        )
+
+    def _get_order_by_id(
+        self,
+        *,
+        order_id: int,
+    ) -> types.Order:
+        """For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions."""
+        path_params: dict[str, Any] = {"orderId": order_id}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/store/order/{orderId}", path_params)
+        response = self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Order.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise GetOrderByIdApiError(
+                response.status_code,
+                self._error(types.GetOrderById400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise GetOrderByIdApiError(
+                response.status_code,
+                self._error(types.GetOrderById404Error, 404, None),
+            )
+        raise GetOrderByIdApiError(
+            response.status_code,
+            self._error(types.GetOrderByIdDefaultError, response.status_code, None),
+        )
+
+    def _get_pet_by_id(
+        self,
+        *,
+        pet_id: int,
+    ) -> types.Pet:
+        """Returns a single pet."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/{petId}", path_params)
+        response = self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise GetPetByIdApiError(
+                response.status_code,
+                self._error(types.GetPetById400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise GetPetByIdApiError(
+                response.status_code,
+                self._error(types.GetPetById404Error, 404, None),
+            )
+        raise GetPetByIdApiError(
+            response.status_code,
+            self._error(types.GetPetByIdDefaultError, response.status_code, None),
+        )
+
+    def _get_user_by_name(
+        self,
+        *,
+        username: str,
+    ) -> types.User:
+        """Get user detail based on username."""
+        path_params: dict[str, Any] = {"username": username}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/{username}", path_params)
+        response = self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.User.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise GetUserByNameApiError(
+                response.status_code,
+                self._error(types.GetUserByName400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise GetUserByNameApiError(
+                response.status_code,
+                self._error(types.GetUserByName404Error, 404, None),
+            )
+        raise GetUserByNameApiError(
+            response.status_code,
+            self._error(types.GetUserByNameDefaultError, response.status_code, None),
+        )
+
+    def _login_user(
+        self,
+        *,
+        username: str | None = None,
+        password: str | None = None,
+    ) -> str:
+        """Log into the system."""
+        query_params: dict[str, Any] = {"username": username, "password": password}
+        query_formats: dict[str, str] | None = {
+            "username": "multi",
+            "password": "multi",
+        }
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/login", {})
+        response = self._client.request(
+            "GET",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return self._json_body(response)
+        if response.status_code == 400:
+            raise LoginUserApiError(
+                response.status_code,
+                self._error(types.LoginUser400Error, 400, None),
+            )
+        raise LoginUserApiError(
+            response.status_code,
+            self._error(types.LoginUserDefaultError, response.status_code, None),
+        )
+
+    def _logout_user(
+        self,
+    ) -> None:
+        """Log user out of the system."""
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/user/logout", {})
+        response = self._client.request(
+            "GET",
+            _request_url,
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        raise LogoutUserApiError(
+            response.status_code,
+            self._error(types.LogoutUserDefaultError, response.status_code, None),
+        )
+
+    def _place_order(
+        self,
+        *,
+        id: int | None = None,
+        pet_id: int | None = None,
+        quantity: int | None = None,
+        ship_date: datetime.datetime | None = None,
+        status: types.OrderStatus | None = None,
+        complete: bool | None = None,
+    ) -> types.Order:
+        """Place a new order in the store."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        if id is not None:
+            _body_fields["id"] = id
+        if pet_id is not None:
+            _body_fields["petId"] = pet_id
+        if quantity is not None:
+            _body_fields["quantity"] = quantity
+        if ship_date is not None:
+            _body_fields["shipDate"] = ship_date
+        if status is not None:
+            _body_fields["status"] = status
+        if complete is not None:
+            _body_fields["complete"] = complete
+        body = types.Order.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/store/order", {})
+        response = self._client.request(
+            "POST",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Order.model_validate(response.json())
+        if response.status_code == 400:
+            raise PlaceOrderApiError(
+                response.status_code,
+                self._error(types.PlaceOrder400Error, 400, None),
+            )
+        if response.status_code == 422:
+            raise PlaceOrderApiError(
+                response.status_code,
+                self._error(types.PlaceOrder422Error, 422, None),
+            )
+        raise PlaceOrderApiError(
+            response.status_code,
+            self._error(types.PlaceOrderDefaultError, response.status_code, None),
+        )
+
+    def _update_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Update an existing pet by Id."""
+        header_params: dict[str, Any] = {}
+        _body_fields: dict[str, Any] = {}
+        _body_fields["name"] = name
+        _body_fields["photoUrls"] = photo_urls
+        if id is not None:
+            _body_fields["id"] = id
+        if category is not None:
+            _body_fields["category"] = category
+        if tags is not None:
+            _body_fields["tags"] = tags
+        if status is not None:
+            _body_fields["status"] = status
+        body = types.Pet.model_validate(_body_fields).model_dump(
+            mode="json", by_alias=True, exclude_unset=True
+        )
+        request_kwargs: dict[str, Any] = {"json": body}
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/pet", {})
+        response = self._client.request(
+            "PUT",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise UpdatePetApiError(
+                response.status_code,
+                self._error(types.UpdatePet400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise UpdatePetApiError(
+                response.status_code,
+                self._error(types.UpdatePet404Error, 404, None),
+            )
+        if response.status_code == 422:
+            raise UpdatePetApiError(
+                response.status_code,
+                self._error(types.UpdatePet422Error, 422, None),
+            )
+        raise UpdatePetApiError(
+            response.status_code,
+            self._error(types.UpdatePetDefaultError, response.status_code, None),
+        )
+
+    def _update_pet_with_form(
+        self,
+        *,
+        pet_id: int,
+        name: str | None = None,
+        status: str | None = None,
+    ) -> types.Pet:
+        """Updates a pet resource based on the form data."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        query_params: dict[str, Any] = {"name": name, "status": status}
+        query_formats: dict[str, str] | None = {"name": "multi", "status": "multi"}
+        request_kwargs: dict[str, Any] = {}
+        _request_url = self._url("/pet/{petId}", path_params)
+        response = self._client.request(
+            "POST",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.Pet.model_validate(self._json_body(response))
+        if response.status_code == 400:
+            raise UpdatePetWithFormApiError(
+                response.status_code,
+                self._error(types.UpdatePetWithForm400Error, 400, None),
+            )
+        raise UpdatePetWithFormApiError(
+            response.status_code,
+            self._error(
+                types.UpdatePetWithFormDefaultError, response.status_code, None
+            ),
+        )
+
+    def _update_user(
+        self,
+        *,
+        username: str,
+        body: types.User | None = None,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        path_params: dict[str, Any] = {"username": username}
+        header_params: dict[str, Any] = {}
+        body = self._dump(body)
+        request_kwargs: dict[str, Any] = {"json": body}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/json")
+        _request_url = self._url("/user/{username}", path_params)
+        response = self._client.request(
+            "PUT",
+            _request_url,
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return None
+        if response.status_code == 400:
+            raise UpdateUserApiError(
+                response.status_code,
+                self._error(types.UpdateUser400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise UpdateUserApiError(
+                response.status_code,
+                self._error(types.UpdateUser404Error, 404, None),
+            )
+        raise UpdateUserApiError(
+            response.status_code,
+            self._error(types.UpdateUserDefaultError, response.status_code, None),
+        )
+
+    def _upload_file(
+        self,
+        *,
+        pet_id: int,
+        additional_metadata: str | None = None,
+        body: bytes | None = None,
+    ) -> types.ApiResponse:
+        """Upload image of the pet."""
+        path_params: dict[str, Any] = {"petId": pet_id}
+        query_params: dict[str, Any] = {"additionalMetadata": additional_metadata}
+        header_params: dict[str, Any] = {}
+        query_formats: dict[str, str] | None = {"additionalMetadata": "multi"}
+        body = body
+        request_kwargs: dict[str, Any] = {"content": body}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "application/octet-stream")
+        _request_url = self._url("/pet/{petId}/uploadImage", path_params)
+        response = self._client.request(
+            "POST",
+            _request_url,
+            params=self._query(query_params, query_formats),
+            headers=self._headers(header_params),
+            **request_kwargs,
+        )
+        if response.status_code == 200:
+            return types.ApiResponse.model_validate(response.json())
+        if response.status_code == 400:
+            raise UploadFileApiError(
+                response.status_code,
+                self._error(types.UploadFile400Error, 400, None),
+            )
+        if response.status_code == 404:
+            raise UploadFileApiError(
+                response.status_code,
+                self._error(types.UploadFile404Error, 404, None),
+            )
+        raise UploadFileApiError(
+            response.status_code,
+            self._error(types.UploadFileDefaultError, response.status_code, None),
+        )
+
+
+class _PetNamespace:
+    """\`pet\` operations."""
+
+    def __init__(self, parent: SwaggerPetstoreOpenAPI30) -> None:
+        self._parent = parent
+
+    def add_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Add a new pet to the store."""
+        return self._parent._add_pet(
+            name=name,
+            photo_urls=photo_urls,
+            id=id,
+            category=category,
+            tags=tags,
+            status=status,
+        )
+
+    def delete_pet(
+        self,
+        *,
+        pet_id: int,
+        api_key: str | None = None,
+    ) -> None:
+        """Delete a pet."""
+        return self._parent._delete_pet(
+            pet_id=pet_id,
+            api_key=api_key,
+        )
+
+    def find_pets_by_status(
+        self,
+        *,
+        status: Literal["available", "pending", "sold"] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple status values can be provided with comma separated strings."""
+        return self._parent._find_pets_by_status(
+            status=status,
+        )
+
+    def find_pets_by_tags(
+        self,
+        *,
+        tags: list[str] | None = None,
+    ) -> list[types.Pet]:
+        """Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing."""
+        return self._parent._find_pets_by_tags(
+            tags=tags,
+        )
+
+    def get_pet_by_id(
+        self,
+        *,
+        pet_id: int,
+    ) -> types.Pet:
+        """Returns a single pet."""
+        return self._parent._get_pet_by_id(
+            pet_id=pet_id,
+        )
+
+    def update_pet(
+        self,
+        *,
+        name: str,
+        photo_urls: list[str],
+        id: int | None = None,
+        category: types.Category | None = None,
+        tags: list[types.Tag] | None = None,
+        status: types.PetStatus | None = None,
+    ) -> types.Pet:
+        """Update an existing pet by Id."""
+        return self._parent._update_pet(
+            name=name,
+            photo_urls=photo_urls,
+            id=id,
+            category=category,
+            tags=tags,
+            status=status,
+        )
+
+    def update_pet_with_form(
+        self,
+        *,
+        pet_id: int,
+        name: str | None = None,
+        status: str | None = None,
+    ) -> types.Pet:
+        """Updates a pet resource based on the form data."""
+        return self._parent._update_pet_with_form(
+            pet_id=pet_id,
+            name=name,
+            status=status,
+        )
+
+    def upload_file(
+        self,
+        *,
+        pet_id: int,
+        additional_metadata: str | None = None,
+        body: bytes | None = None,
+    ) -> types.ApiResponse:
+        """Upload image of the pet."""
+        return self._parent._upload_file(
+            pet_id=pet_id,
+            additional_metadata=additional_metadata,
+            body=body,
+        )
+
+
+class _UserNamespace:
+    """\`user\` operations."""
+
+    def __init__(self, parent: SwaggerPetstoreOpenAPI30) -> None:
+        self._parent = parent
+
+    def create_user(
+        self,
+        *,
+        id: int | None = None,
+        username: str | None = None,
+        first_name: str | None = None,
+        last_name: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        phone: str | None = None,
+        user_status: int | None = None,
+    ) -> types.User:
+        """This can only be done by the logged in user."""
+        return self._parent._create_user(
+            id=id,
+            username=username,
+            first_name=first_name,
+            last_name=last_name,
+            email=email,
+            password=password,
+            phone=phone,
+            user_status=user_status,
+        )
+
+    def create_users_with_list_input(
+        self,
+        body: list[types.User] | None = None,
+    ) -> types.User:
+        """Creates list of users with given input array."""
+        return self._parent._create_users_with_list_input(
+            body,
+        )
+
+    def delete_user(
+        self,
+        *,
+        username: str,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        return self._parent._delete_user(
+            username=username,
+        )
+
+    def get_user_by_name(
+        self,
+        *,
+        username: str,
+    ) -> types.User:
+        """Get user detail based on username."""
+        return self._parent._get_user_by_name(
+            username=username,
+        )
+
+    def login_user(
+        self,
+        *,
+        username: str | None = None,
+        password: str | None = None,
+    ) -> str:
+        """Log into the system."""
+        return self._parent._login_user(
+            username=username,
+            password=password,
+        )
+
+    def logout_user(
+        self,
+    ) -> None:
+        """Log user out of the system."""
+        return self._parent._logout_user()
+
+    def update_user(
+        self,
+        *,
+        username: str,
+        body: types.User | None = None,
+    ) -> None:
+        """This can only be done by the logged in user."""
+        return self._parent._update_user(
+            username=username,
+            body=body,
+        )
+
+
+class _StoreNamespace:
+    """\`store\` operations."""
+
+    def __init__(self, parent: SwaggerPetstoreOpenAPI30) -> None:
+        self._parent = parent
+
+    def delete_order(
+        self,
+        *,
+        order_id: int,
+    ) -> None:
+        """
+        For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API
+        errors.
+        """
+        return self._parent._delete_order(
+            order_id=order_id,
+        )
+
+    def get_inventory(
+        self,
+    ) -> types.GetInventory200Response:
+        """Returns a map of status codes to quantities."""
+        return self._parent._get_inventory()
+
+    def get_order_by_id(
+        self,
+        *,
+        order_id: int,
+    ) -> types.Order:
+        """For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions."""
+        return self._parent._get_order_by_id(
+            order_id=order_id,
+        )
+
+    def place_order(
+        self,
+        *,
+        id: int | None = None,
+        pet_id: int | None = None,
+        quantity: int | None = None,
+        ship_date: datetime.datetime | None = None,
+        status: types.OrderStatus | None = None,
+        complete: bool | None = None,
+    ) -> types.Order:
+        """Place a new order in the store."""
+        return self._parent._place_order(
+            id=id,
+            pet_id=pet_id,
+            quantity=quantity,
+            ship_date=ship_date,
+            status=status,
+            complete=complete,
+        )
+"
+`;
+
+exports[`openApiPyClientGenerator - petstore > should generate valid Python for the full petstore example > types.py 1`] = `
+""""Types for SwaggerPetstoreOpenAPI30 — AUTO-GENERATED, do not edit."""
+
+from __future__ import annotations
+
+import datetime
+from typing import Literal, TypedDict
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ApiResponse(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    code: int | None = None
+    var_type: str | None = Field(default=None, alias="type")
+    message: str | None = None
+
+
+class Category(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    id: int | None = None
+    name: str | None = None
+
+
+class DeleteOrderRequestPathParameters(BaseModel):
+    """
+    For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    order_id: int = Field(
+        alias="orderId", description="ID of the order that needs to be deleted"
+    )
+
+
+class DeletePetRequestHeaderParameters(BaseModel):
+    """Delete a pet."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    api_key: str | None = None
+
+
+class DeletePetRequestPathParameters(BaseModel):
+    """Delete a pet."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    pet_id: int = Field(alias="petId", description="Pet id to delete")
+
+
+class DeleteUserRequestPathParameters(BaseModel):
+    """This can only be done by the logged in user."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    username: str = Field(description="The name that needs to be deleted")
+
+
+class FindPetsByStatusRequestQueryParameters(BaseModel):
+    """Multiple status values can be provided with comma separated strings."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal["available", "pending", "sold"] | None = Field(
+        default=None, description="Status values that need to be considered for filter"
+    )
+
+
+class FindPetsByTagsRequestQueryParameters(BaseModel):
+    """Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    tags: list[str] | None = Field(default=None, description="Tags to filter by")
+
+
+class GetOrderByIdRequestPathParameters(BaseModel):
+    """For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    order_id: int = Field(
+        alias="orderId", description="ID of order that needs to be fetched"
+    )
+
+
+class GetPetByIdRequestPathParameters(BaseModel):
+    """Returns a single pet."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    pet_id: int = Field(alias="petId", description="ID of pet to return")
+
+
+class GetUserByNameRequestPathParameters(BaseModel):
+    """Get user detail based on username."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    username: str = Field(
+        description="The name that needs to be fetched. Use user1 for testing"
+    )
+
+
+class LoginUserRequestQueryParameters(BaseModel):
+    """Log into the system."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    username: str | None = Field(default=None, description="The user name for login")
+    password: str | None = Field(
+        default=None, description="The password for login in clear text"
+    )
+
+
+class Order(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    id: int | None = None
+    pet_id: int | None = Field(default=None, alias="petId")
+    quantity: int | None = None
+    ship_date: datetime.datetime | None = Field(default=None, alias="shipDate")
+    status: OrderStatus | None = None
+    complete: bool | None = None
+
+
+class Pet(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    id: int | None = None
+    name: str
+    category: Category | None = None
+    photo_urls: list[str] = Field(alias="photoUrls")
+    tags: list[Tag] | None = None
+    status: PetStatus | None = None
+
+
+class Tag(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    id: int | None = None
+    name: str | None = None
+
+
+class UpdatePetWithFormRequestPathParameters(BaseModel):
+    """Updates a pet resource based on the form data."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    pet_id: int = Field(alias="petId", description="ID of pet that needs to be updated")
+
+
+class UpdatePetWithFormRequestQueryParameters(BaseModel):
+    """Updates a pet resource based on the form data."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    name: str | None = Field(
+        default=None, description="Name of pet that needs to be updated"
+    )
+    status: str | None = Field(
+        default=None, description="Status of pet that needs to be updated"
+    )
+
+
+class UpdateUserRequestBodyParameters(BaseModel):
+    """This can only be done by the logged in user."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    body: User | None = Field(
+        default=None, description="Update an existent user in the store"
+    )
+
+
+class UpdateUserRequestPathParameters(BaseModel):
+    """This can only be done by the logged in user."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    username: str = Field(description="name that need to be deleted")
+
+
+class UploadFileRequestBodyParameters(BaseModel):
+    """Upload image of the pet."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    body: bytes | None = None
+
+
+class UploadFileRequestPathParameters(BaseModel):
+    """Upload image of the pet."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    pet_id: int = Field(alias="petId", description="ID of pet to update")
+
+
+class UploadFileRequestQueryParameters(BaseModel):
+    """Upload image of the pet."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    additional_metadata: str | None = Field(
+        default=None, alias="additionalMetadata", description="Additional Metadata"
+    )
+
+
+class User(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    id: int | None = None
+    username: str | None = None
+    first_name: str | None = Field(default=None, alias="firstName")
+    last_name: str | None = Field(default=None, alias="lastName")
+    email: str | None = None
+    password: str | None = None
+    phone: str | None = None
+    user_status: int | None = Field(
+        default=None, alias="userStatus", description="User Status"
+    )
+
+
+GetInventory200Response = dict[str, int]
+
+OrderStatus = Literal["placed", "approved", "delivered"]
+"""Order Status"""
+
+PetStatus = Literal["available", "pending", "sold"]
+"""pet status in the store"""
+
+
+class AddPetRequest(TypedDict):
+    """Add a new pet to the store."""
+
+    body: Pet
+
+
+class CreateUserRequest(TypedDict, total=False):
+    """This can only be done by the logged in user."""
+
+    body: User
+
+
+class CreateUsersWithListInputRequest(TypedDict, total=False):
+    """Creates list of users with given input array."""
+
+    body: list[User]
+
+
+class DeleteOrderRequest(TypedDict):
+    """
+    For valid response try integer IDs with value < 1000. Anything above 1000 or non-integers will generate API errors.
+    """
+
+    order_id: int
+
+
+class DeletePetRequestRequired(TypedDict):
+    pet_id: int
+
+
+class DeletePetRequest(DeletePetRequestRequired, total=False):
+    """Delete a pet."""
+
+    api_key: str
+
+
+class DeleteUserRequest(TypedDict):
+    """This can only be done by the logged in user."""
+
+    username: str
+
+
+class FindPetsByStatusRequest(TypedDict, total=False):
+    """Multiple status values can be provided with comma separated strings."""
+
+    status: Literal["available", "pending", "sold"]
+
+
+class FindPetsByTagsRequest(TypedDict, total=False):
+    """Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing."""
+
+    tags: list[str]
+
+
+class GetOrderByIdRequest(TypedDict):
+    """For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions."""
+
+    order_id: int
+
+
+class GetPetByIdRequest(TypedDict):
+    """Returns a single pet."""
+
+    pet_id: int
+
+
+class GetUserByNameRequest(TypedDict):
+    """Get user detail based on username."""
+
+    username: str
+
+
+class LoginUserRequest(TypedDict, total=False):
+    """Log into the system."""
+
+    username: str
+    password: str
+
+
+class PlaceOrderRequest(TypedDict, total=False):
+    """Place a new order in the store."""
+
+    body: Order
+
+
+class UpdatePetRequest(TypedDict):
+    """Update an existing pet by Id."""
+
+    body: Pet
+
+
+class UpdatePetWithFormRequestRequired(TypedDict):
+    pet_id: int
+
+
+class UpdatePetWithFormRequest(UpdatePetWithFormRequestRequired, total=False):
+    """Updates a pet resource based on the form data."""
+
+    name: str
+    status: str
+
+
+class UpdateUserRequestRequired(TypedDict):
+    username: str
+
+
+class UpdateUserRequest(UpdateUserRequestRequired, total=False):
+    """This can only be done by the logged in user."""
+
+    body: User
+
+
+class UploadFileRequestRequired(TypedDict):
+    pet_id: int
+
+
+class UploadFileRequest(UploadFileRequestRequired, total=False):
+    """Upload image of the pet."""
+
+    additional_metadata: str
+    body: bytes
+
+
+class AddPet400Error(BaseModel):
+    """Error wrapper for AddPet status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class AddPet422Error(BaseModel):
+    """Error wrapper for AddPet status 422."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[422]
+    error: None
+
+
+class AddPetDefaultError(BaseModel):
+    """Error wrapper for AddPet status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+AddPetError = AddPet400Error | AddPet422Error | AddPetDefaultError
+
+
+class CreateUserDefaultError(BaseModel):
+    """Error wrapper for CreateUser status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+CreateUserError = CreateUserDefaultError
+
+
+class CreateUsersWithListInputDefaultError(BaseModel):
+    """Error wrapper for CreateUsersWithListInput status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+CreateUsersWithListInputError = CreateUsersWithListInputDefaultError
+
+
+class DeleteOrder400Error(BaseModel):
+    """Error wrapper for DeleteOrder status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class DeleteOrder404Error(BaseModel):
+    """Error wrapper for DeleteOrder status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class DeleteOrderDefaultError(BaseModel):
+    """Error wrapper for DeleteOrder status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+DeleteOrderError = DeleteOrder400Error | DeleteOrder404Error | DeleteOrderDefaultError
+
+
+class DeletePet400Error(BaseModel):
+    """Error wrapper for DeletePet status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class DeletePetDefaultError(BaseModel):
+    """Error wrapper for DeletePet status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+DeletePetError = DeletePet400Error | DeletePetDefaultError
+
+
+class DeleteUser400Error(BaseModel):
+    """Error wrapper for DeleteUser status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class DeleteUser404Error(BaseModel):
+    """Error wrapper for DeleteUser status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class DeleteUserDefaultError(BaseModel):
+    """Error wrapper for DeleteUser status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+DeleteUserError = DeleteUser400Error | DeleteUser404Error | DeleteUserDefaultError
+
+
+class FindPetsByStatus400Error(BaseModel):
+    """Error wrapper for FindPetsByStatus status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class FindPetsByStatusDefaultError(BaseModel):
+    """Error wrapper for FindPetsByStatus status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+FindPetsByStatusError = FindPetsByStatus400Error | FindPetsByStatusDefaultError
+
+
+class FindPetsByTags400Error(BaseModel):
+    """Error wrapper for FindPetsByTags status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class FindPetsByTagsDefaultError(BaseModel):
+    """Error wrapper for FindPetsByTags status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+FindPetsByTagsError = FindPetsByTags400Error | FindPetsByTagsDefaultError
+
+
+class GetInventoryDefaultError(BaseModel):
+    """Error wrapper for GetInventory status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+GetInventoryError = GetInventoryDefaultError
+
+
+class GetOrderById400Error(BaseModel):
+    """Error wrapper for GetOrderById status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class GetOrderById404Error(BaseModel):
+    """Error wrapper for GetOrderById status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class GetOrderByIdDefaultError(BaseModel):
+    """Error wrapper for GetOrderById status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+GetOrderByIdError = (
+    GetOrderById400Error | GetOrderById404Error | GetOrderByIdDefaultError
+)
+
+
+class GetPetById400Error(BaseModel):
+    """Error wrapper for GetPetById status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class GetPetById404Error(BaseModel):
+    """Error wrapper for GetPetById status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class GetPetByIdDefaultError(BaseModel):
+    """Error wrapper for GetPetById status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+GetPetByIdError = GetPetById400Error | GetPetById404Error | GetPetByIdDefaultError
+
+
+class GetUserByName400Error(BaseModel):
+    """Error wrapper for GetUserByName status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class GetUserByName404Error(BaseModel):
+    """Error wrapper for GetUserByName status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class GetUserByNameDefaultError(BaseModel):
+    """Error wrapper for GetUserByName status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+GetUserByNameError = (
+    GetUserByName400Error | GetUserByName404Error | GetUserByNameDefaultError
+)
+
+
+class LoginUser400Error(BaseModel):
+    """Error wrapper for LoginUser status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class LoginUserDefaultError(BaseModel):
+    """Error wrapper for LoginUser status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+LoginUserError = LoginUser400Error | LoginUserDefaultError
+
+
+class LogoutUserDefaultError(BaseModel):
+    """Error wrapper for LogoutUser status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+LogoutUserError = LogoutUserDefaultError
+
+
+class PlaceOrder400Error(BaseModel):
+    """Error wrapper for PlaceOrder status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class PlaceOrder422Error(BaseModel):
+    """Error wrapper for PlaceOrder status 422."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[422]
+    error: None
+
+
+class PlaceOrderDefaultError(BaseModel):
+    """Error wrapper for PlaceOrder status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+PlaceOrderError = PlaceOrder400Error | PlaceOrder422Error | PlaceOrderDefaultError
+
+
+class UpdatePet400Error(BaseModel):
+    """Error wrapper for UpdatePet status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class UpdatePet404Error(BaseModel):
+    """Error wrapper for UpdatePet status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class UpdatePet422Error(BaseModel):
+    """Error wrapper for UpdatePet status 422."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[422]
+    error: None
+
+
+class UpdatePetDefaultError(BaseModel):
+    """Error wrapper for UpdatePet status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+UpdatePetError = (
+    UpdatePet400Error | UpdatePet404Error | UpdatePet422Error | UpdatePetDefaultError
+)
+
+
+class UpdatePetWithForm400Error(BaseModel):
+    """Error wrapper for UpdatePetWithForm status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class UpdatePetWithFormDefaultError(BaseModel):
+    """Error wrapper for UpdatePetWithForm status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+UpdatePetWithFormError = UpdatePetWithForm400Error | UpdatePetWithFormDefaultError
+
+
+class UpdateUser400Error(BaseModel):
+    """Error wrapper for UpdateUser status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class UpdateUser404Error(BaseModel):
+    """Error wrapper for UpdateUser status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class UpdateUserDefaultError(BaseModel):
+    """Error wrapper for UpdateUser status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+UpdateUserError = UpdateUser400Error | UpdateUser404Error | UpdateUserDefaultError
+
+
+class UploadFile400Error(BaseModel):
+    """Error wrapper for UploadFile status 400."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[400]
+    error: None
+
+
+class UploadFile404Error(BaseModel):
+    """Error wrapper for UploadFile status 404."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: Literal[404]
+    error: None
+
+
+class UploadFileDefaultError(BaseModel):
+    """Error wrapper for UploadFile status default."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: int
+    error: None
+
+
+UploadFileError = UploadFile400Error | UploadFile404Error | UploadFileDefaultError
+"
+`;