text: from typing import Any, Dict, List, Optional, Union, cast
  
  import httpx
  
  from ...client import AuthenticatedClient, Client
  from ...models.historical_deployment_delta import HistoricalDeploymentDelta
  from ...types import UNSET, Response
  
  
  def _get_kwargs(
      *,
      client: AuthenticatedClient,
      id: str,
  ) -> Dict[str, Any]:
      url = "{}/api/deployments/{id}/changes".format(client.base_url, id=id)
  
      headers: Dict[str, Any] = client.get_headers()
      cookies: Dict[str, Any] = client.get_cookies()
  
      return {
          "url": url,
          "headers": headers,
          "cookies": cookies,
          "timeout": client.get_timeout(),
      }
  
  
  def _parse_response(*, response: httpx.Response) -> Optional[List[HistoricalDeploymentDelta]]:
      if response.status_code == 200:
          response_200 = []
          _response_200 = response.json()
          for response_200_item_data in _response_200:
              response_200_item = HistoricalDeploymentDelta.from_dict(response_200_item_data)
  
              response_200.append(response_200_item)
  
          return response_200
      return None
  
  
  def _build_response(*, response: httpx.Response) -> Response[List[HistoricalDeploymentDelta]]:
      return Response(
          status_code=response.status_code,
          content=response.content,
          headers=response.headers,
          parsed=_parse_response(response=response),
      )
  
  
  def sync_detailed(
      *,
      client: AuthenticatedClient,
      id: str,
  ) -> Response[List[HistoricalDeploymentDelta]]:
      kwargs = _get_kwargs(
          client=client,
          id=id,
      )
  
      response = httpx.get(
          **kwargs,
      )
  
      return _build_response(response=response)
  
  
  def sync(
      *,
      client: AuthenticatedClient,
      id: str,
  ) -> Optional[List[HistoricalDeploymentDelta]]:
      """ """
  
      return sync_detailed(
          client=client,
          id=id,
      ).parsed
  
  
  async def asyncio_detailed(
      *,
      client: AuthenticatedClient,
      id: str,
  ) -> Response[List[HistoricalDeploymentDelta]]:
      kwargs = _get_kwargs(
          client=client,
          id=id,
      )
  
      async with httpx.AsyncClient() as _client:
          response = await _client.get(**kwargs)
  
      return _build_response(response=response)
  
  
  async def asyncio(
      *,
      client: AuthenticatedClient,
      id: str,
  ) -> Optional[List[HistoricalDeploymentDelta]]:
      """ """
  
      return (
          await asyncio_detailed(
              client=client,
              id=id,
          )
      ).parsed
  