re-uploading work

tests/generated_client/api/__init__.py

@@ -0,0 +1 @@
+""" Contains methods for accessing the API """

tests/generated_client/api/actions/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/actions/create_action.py

@@ -0,0 +1,191 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.create_action_request import CreateActionRequest
+from ...models.create_action_response_201 import CreateActionResponse201
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateActionRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/actions",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | CreateActionResponse201 | None:
+    if response.status_code == 201:
+        response_201 = CreateActionResponse201.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | CreateActionResponse201]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateActionRequest,
+
+) -> Response[Any | CreateActionResponse201]:
+    """ Create a new action
+
+    Args:
+        body (CreateActionRequest): Request DTO for creating a new action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreateActionResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: CreateActionRequest,
+
+) -> Any | CreateActionResponse201 | None:
+    """ Create a new action
+
+    Args:
+        body (CreateActionRequest): Request DTO for creating a new action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreateActionResponse201
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateActionRequest,
+
+) -> Response[Any | CreateActionResponse201]:
+    """ Create a new action
+
+    Args:
+        body (CreateActionRequest): Request DTO for creating a new action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreateActionResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: CreateActionRequest,
+
+) -> Any | CreateActionResponse201 | None:
+    """ Create a new action
+
+    Args:
+        body (CreateActionRequest): Request DTO for creating a new action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreateActionResponse201
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/actions/delete_action.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/actions/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/actions/get_action.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_action_response_200 import GetActionResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/actions/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetActionResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetActionResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetActionResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetActionResponse200]:
+    """ Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetActionResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetActionResponse200 | None:
+    """ Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetActionResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetActionResponse200]:
+    """ Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetActionResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetActionResponse200 | None:
+    """ Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetActionResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/actions/get_queue_stats.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_queue_stats_response_200 import GetQueueStatsResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/actions/{ref}/queue-stats".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetQueueStatsResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetQueueStatsResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetQueueStatsResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetQueueStatsResponse200]:
+    """ Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetQueueStatsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetQueueStatsResponse200 | None:
+    """ Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetQueueStatsResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetQueueStatsResponse200]:
+    """ Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetQueueStatsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetQueueStatsResponse200 | None:
+    """ Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetQueueStatsResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/actions/list_actions.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_action_summary import PaginatedResponseActionSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/actions",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> PaginatedResponseActionSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseActionSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[PaginatedResponseActionSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[PaginatedResponseActionSummary]:
+    """ List all actions with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponseActionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> PaginatedResponseActionSummary | None:
+    """ List all actions with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponseActionSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[PaginatedResponseActionSummary]:
+    """ List all actions with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponseActionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> PaginatedResponseActionSummary | None:
+    """ List all actions with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponseActionSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/actions/list_actions_by_pack.py

@@ -0,0 +1,212 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_action_summary import PaginatedResponseActionSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    pack_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{pack_ref}/actions".format(pack_ref=quote(str(pack_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseActionSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseActionSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseActionSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseActionSummary]:
+    """ List actions by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseActionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseActionSummary | None:
+    """ List actions by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseActionSummary
+     """
+
+
+    return sync_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseActionSummary]:
+    """ List actions by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseActionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseActionSummary | None:
+    """ List actions by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseActionSummary
+     """
+
+
+    return (await asyncio_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/actions/update_action.py

@@ -0,0 +1,200 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.update_action_request import UpdateActionRequest
+from ...models.update_action_response_200 import UpdateActionResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    body: UpdateActionRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/actions/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | UpdateActionResponse200 | None:
+    if response.status_code == 200:
+        response_200 = UpdateActionResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | UpdateActionResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateActionRequest,
+
+) -> Response[Any | UpdateActionResponse200]:
+    """ Update an existing action
+
+    Args:
+        ref (str):
+        body (UpdateActionRequest): Request DTO for updating an action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | UpdateActionResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateActionRequest,
+
+) -> Any | UpdateActionResponse200 | None:
+    """ Update an existing action
+
+    Args:
+        ref (str):
+        body (UpdateActionRequest): Request DTO for updating an action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | UpdateActionResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateActionRequest,
+
+) -> Response[Any | UpdateActionResponse200]:
+    """ Update an existing action
+
+    Args:
+        ref (str):
+        body (UpdateActionRequest): Request DTO for updating an action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | UpdateActionResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateActionRequest,
+
+) -> Any | UpdateActionResponse200 | None:
+    """ Update an existing action
+
+    Args:
+        ref (str):
+        body (UpdateActionRequest): Request DTO for updating an action
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | UpdateActionResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/auth/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/auth/change_password.py

@@ -0,0 +1,181 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.change_password_request import ChangePasswordRequest
+from ...models.change_password_response_200 import ChangePasswordResponse200
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    body: ChangePasswordRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/auth/change-password",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | ChangePasswordResponse200 | None:
+    if response.status_code == 200:
+        response_200 = ChangePasswordResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | ChangePasswordResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: ChangePasswordRequest,
+) -> Response[Any | ChangePasswordResponse200]:
+    """Change password endpoint
+
+     POST /auth/change-password
+
+    Args:
+        body (ChangePasswordRequest): Change password request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ChangePasswordResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: ChangePasswordRequest,
+) -> Any | ChangePasswordResponse200 | None:
+    """Change password endpoint
+
+     POST /auth/change-password
+
+    Args:
+        body (ChangePasswordRequest): Change password request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ChangePasswordResponse200
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: ChangePasswordRequest,
+) -> Response[Any | ChangePasswordResponse200]:
+    """Change password endpoint
+
+     POST /auth/change-password
+
+    Args:
+        body (ChangePasswordRequest): Change password request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ChangePasswordResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: ChangePasswordRequest,
+) -> Any | ChangePasswordResponse200 | None:
+    """Change password endpoint
+
+     POST /auth/change-password
+
+    Args:
+        body (ChangePasswordRequest): Change password request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ChangePasswordResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

tests/generated_client/api/auth/get_current_user.py

@@ -0,0 +1,144 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.get_current_user_response_200 import GetCurrentUserResponse200
+from ...types import UNSET, Response
+
+
+def _get_kwargs() -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/auth/me",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | GetCurrentUserResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetCurrentUserResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | GetCurrentUserResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | GetCurrentUserResponse200]:
+    """Get current user endpoint
+
+     GET /auth/me
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetCurrentUserResponse200]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+) -> Any | GetCurrentUserResponse200 | None:
+    """Get current user endpoint
+
+     GET /auth/me
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetCurrentUserResponse200
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | GetCurrentUserResponse200]:
+    """Get current user endpoint
+
+     GET /auth/me
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetCurrentUserResponse200]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+) -> Any | GetCurrentUserResponse200 | None:
+    """Get current user endpoint
+
+     GET /auth/me
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetCurrentUserResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

tests/generated_client/api/auth/login.py

@@ -0,0 +1,177 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.login_request import LoginRequest
+from ...models.login_response_200 import LoginResponse200
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    body: LoginRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/auth/login",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | LoginResponse200 | None:
+    if response.status_code == 200:
+        response_200 = LoginResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | LoginResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: LoginRequest,
+) -> Response[Any | LoginResponse200]:
+    """Login endpoint
+
+     POST /auth/login
+
+    Args:
+        body (LoginRequest): Login request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | LoginResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: LoginRequest,
+) -> Any | LoginResponse200 | None:
+    """Login endpoint
+
+     POST /auth/login
+
+    Args:
+        body (LoginRequest): Login request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | LoginResponse200
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: LoginRequest,
+) -> Response[Any | LoginResponse200]:
+    """Login endpoint
+
+     POST /auth/login
+
+    Args:
+        body (LoginRequest): Login request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | LoginResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: LoginRequest,
+) -> Any | LoginResponse200 | None:
+    """Login endpoint
+
+     POST /auth/login
+
+    Args:
+        body (LoginRequest): Login request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | LoginResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

tests/generated_client/api/auth/refresh_token.py

@@ -0,0 +1,177 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.refresh_token_request import RefreshTokenRequest
+from ...models.refresh_token_response_200 import RefreshTokenResponse200
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    body: RefreshTokenRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/auth/refresh",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | RefreshTokenResponse200 | None:
+    if response.status_code == 200:
+        response_200 = RefreshTokenResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | RefreshTokenResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RefreshTokenRequest,
+) -> Response[Any | RefreshTokenResponse200]:
+    """Refresh token endpoint
+
+     POST /auth/refresh
+
+    Args:
+        body (RefreshTokenRequest): Refresh token request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | RefreshTokenResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RefreshTokenRequest,
+) -> Any | RefreshTokenResponse200 | None:
+    """Refresh token endpoint
+
+     POST /auth/refresh
+
+    Args:
+        body (RefreshTokenRequest): Refresh token request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | RefreshTokenResponse200
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RefreshTokenRequest,
+) -> Response[Any | RefreshTokenResponse200]:
+    """Refresh token endpoint
+
+     POST /auth/refresh
+
+    Args:
+        body (RefreshTokenRequest): Refresh token request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | RefreshTokenResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RefreshTokenRequest,
+) -> Any | RefreshTokenResponse200 | None:
+    """Refresh token endpoint
+
+     POST /auth/refresh
+
+    Args:
+        body (RefreshTokenRequest): Refresh token request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | RefreshTokenResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

tests/generated_client/api/auth/register.py

@@ -0,0 +1,177 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.register_request import RegisterRequest
+from ...models.register_response_200 import RegisterResponse200
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    body: RegisterRequest,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/auth/register",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | RegisterResponse200 | None:
+    if response.status_code == 200:
+        response_200 = RegisterResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | RegisterResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RegisterRequest,
+) -> Response[Any | RegisterResponse200]:
+    """Register endpoint
+
+     POST /auth/register
+
+    Args:
+        body (RegisterRequest): Register request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | RegisterResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RegisterRequest,
+) -> Any | RegisterResponse200 | None:
+    """Register endpoint
+
+     POST /auth/register
+
+    Args:
+        body (RegisterRequest): Register request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | RegisterResponse200
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RegisterRequest,
+) -> Response[Any | RegisterResponse200]:
+    """Register endpoint
+
+     POST /auth/register
+
+    Args:
+        body (RegisterRequest): Register request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | RegisterResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: RegisterRequest,
+) -> Any | RegisterResponse200 | None:
+    """Register endpoint
+
+     POST /auth/register
+
+    Args:
+        body (RegisterRequest): Register request
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | RegisterResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

tests/generated_client/api/enforcements/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/enforcements/get_enforcement.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_enforcement_response import ApiResponseEnforcementResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/enforcements/{id}".format(id=quote(str(id), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseEnforcementResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseEnforcementResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseEnforcementResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ApiResponseEnforcementResponse]:
+    """ Get a single enforcement by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseEnforcementResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ApiResponseEnforcementResponse | None:
+    """ Get a single enforcement by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseEnforcementResponse
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ApiResponseEnforcementResponse]:
+    """ Get a single enforcement by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseEnforcementResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ApiResponseEnforcementResponse | None:
+    """ Get a single enforcement by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseEnforcementResponse
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+
+    )).parsed

tests/generated_client/api/enforcements/list_enforcements.py

@@ -0,0 +1,286 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.enforcement_status import EnforcementStatus
+from ...models.paginated_response_enforcement_summary import PaginatedResponseEnforcementSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    rule: int | None | Unset = UNSET,
+    event: int | None | Unset = UNSET,
+    status: EnforcementStatus | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    json_rule: int | None | Unset
+    if isinstance(rule, Unset):
+        json_rule = UNSET
+    else:
+        json_rule = rule
+    params["rule"] = json_rule
+
+    json_event: int | None | Unset
+    if isinstance(event, Unset):
+        json_event = UNSET
+    else:
+        json_event = event
+    params["event"] = json_event
+
+    json_status: None | str | Unset
+    if isinstance(status, Unset):
+        json_status = UNSET
+    elif isinstance(status, EnforcementStatus):
+        json_status = status.value
+    else:
+        json_status = status
+    params["status"] = json_status
+
+    json_trigger_ref: None | str | Unset
+    if isinstance(trigger_ref, Unset):
+        json_trigger_ref = UNSET
+    else:
+        json_trigger_ref = trigger_ref
+    params["trigger_ref"] = json_trigger_ref
+
+    params["page"] = page
+
+    params["per_page"] = per_page
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/enforcements",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseEnforcementSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseEnforcementSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseEnforcementSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    rule: int | None | Unset = UNSET,
+    event: int | None | Unset = UNSET,
+    status: EnforcementStatus | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseEnforcementSummary]:
+    """ List all enforcements with pagination and optional filters
+
+    Args:
+        rule (int | None | Unset):
+        event (int | None | Unset):
+        status (EnforcementStatus | None | Unset):
+        trigger_ref (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseEnforcementSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        rule=rule,
+event=event,
+status=status,
+trigger_ref=trigger_ref,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    rule: int | None | Unset = UNSET,
+    event: int | None | Unset = UNSET,
+    status: EnforcementStatus | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseEnforcementSummary | None:
+    """ List all enforcements with pagination and optional filters
+
+    Args:
+        rule (int | None | Unset):
+        event (int | None | Unset):
+        status (EnforcementStatus | None | Unset):
+        trigger_ref (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseEnforcementSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+rule=rule,
+event=event,
+status=status,
+trigger_ref=trigger_ref,
+page=page,
+per_page=per_page,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    rule: int | None | Unset = UNSET,
+    event: int | None | Unset = UNSET,
+    status: EnforcementStatus | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseEnforcementSummary]:
+    """ List all enforcements with pagination and optional filters
+
+    Args:
+        rule (int | None | Unset):
+        event (int | None | Unset):
+        status (EnforcementStatus | None | Unset):
+        trigger_ref (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseEnforcementSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        rule=rule,
+event=event,
+status=status,
+trigger_ref=trigger_ref,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    rule: int | None | Unset = UNSET,
+    event: int | None | Unset = UNSET,
+    status: EnforcementStatus | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseEnforcementSummary | None:
+    """ List all enforcements with pagination and optional filters
+
+    Args:
+        rule (int | None | Unset):
+        event (int | None | Unset):
+        status (EnforcementStatus | None | Unset):
+        trigger_ref (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseEnforcementSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+rule=rule,
+event=event,
+status=status,
+trigger_ref=trigger_ref,
+page=page,
+per_page=per_page,
+
+    )).parsed

tests/generated_client/api/events/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/events/get_event.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_event_response import ApiResponseEventResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/events/{id}".format(id=quote(str(id), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseEventResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseEventResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseEventResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ApiResponseEventResponse]:
+    """ Get a single event by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseEventResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ApiResponseEventResponse | None:
+    """ Get a single event by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseEventResponse
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ApiResponseEventResponse]:
+    """ Get a single event by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseEventResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ApiResponseEventResponse | None:
+    """ Get a single event by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseEventResponse
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+
+    )).parsed

tests/generated_client/api/events/list_events.py

@@ -0,0 +1,263 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_event_summary import PaginatedResponseEventSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    trigger: int | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    source: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    json_trigger: int | None | Unset
+    if isinstance(trigger, Unset):
+        json_trigger = UNSET
+    else:
+        json_trigger = trigger
+    params["trigger"] = json_trigger
+
+    json_trigger_ref: None | str | Unset
+    if isinstance(trigger_ref, Unset):
+        json_trigger_ref = UNSET
+    else:
+        json_trigger_ref = trigger_ref
+    params["trigger_ref"] = json_trigger_ref
+
+    json_source: int | None | Unset
+    if isinstance(source, Unset):
+        json_source = UNSET
+    else:
+        json_source = source
+    params["source"] = json_source
+
+    params["page"] = page
+
+    params["per_page"] = per_page
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/events",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseEventSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseEventSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseEventSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    trigger: int | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    source: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseEventSummary]:
+    """ List all events with pagination and optional filters
+
+    Args:
+        trigger (int | None | Unset):
+        trigger_ref (None | str | Unset):
+        source (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseEventSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        trigger=trigger,
+trigger_ref=trigger_ref,
+source=source,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    trigger: int | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    source: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseEventSummary | None:
+    """ List all events with pagination and optional filters
+
+    Args:
+        trigger (int | None | Unset):
+        trigger_ref (None | str | Unset):
+        source (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseEventSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+trigger=trigger,
+trigger_ref=trigger_ref,
+source=source,
+page=page,
+per_page=per_page,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    trigger: int | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    source: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseEventSummary]:
+    """ List all events with pagination and optional filters
+
+    Args:
+        trigger (int | None | Unset):
+        trigger_ref (None | str | Unset):
+        source (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseEventSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        trigger=trigger,
+trigger_ref=trigger_ref,
+source=source,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    trigger: int | None | Unset = UNSET,
+    trigger_ref: None | str | Unset = UNSET,
+    source: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseEventSummary | None:
+    """ List all events with pagination and optional filters
+
+    Args:
+        trigger (int | None | Unset):
+        trigger_ref (None | str | Unset):
+        source (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseEventSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+trigger=trigger,
+trigger_ref=trigger_ref,
+source=source,
+page=page,
+per_page=per_page,
+
+    )).parsed

tests/generated_client/api/executions/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/executions/get_execution.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_execution_response_200 import GetExecutionResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/executions/{id}".format(id=quote(str(id), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetExecutionResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetExecutionResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetExecutionResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetExecutionResponse200]:
+    """ Get a single execution by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetExecutionResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetExecutionResponse200 | None:
+    """ Get a single execution by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetExecutionResponse200
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetExecutionResponse200]:
+    """ Get a single execution by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetExecutionResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetExecutionResponse200 | None:
+    """ Get a single execution by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetExecutionResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+
+    )).parsed

tests/generated_client/api/executions/get_execution_stats.py

@@ -0,0 +1,154 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_execution_stats_response_200 import GetExecutionStatsResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/executions/stats",
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetExecutionStatsResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetExecutionStatsResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetExecutionStatsResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetExecutionStatsResponse200]:
+    """ Get execution statistics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetExecutionStatsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetExecutionStatsResponse200 | None:
+    """ Get execution statistics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetExecutionStatsResponse200
+     """
+
+
+    return sync_detailed(
+        client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetExecutionStatsResponse200]:
+    """ Get execution statistics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetExecutionStatsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetExecutionStatsResponse200 | None:
+    """ Get execution statistics
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetExecutionStatsResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+
+    )).parsed

tests/generated_client/api/executions/list_executions.py

@@ -0,0 +1,318 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.execution_status import ExecutionStatus
+from ...models.paginated_response_execution_summary import PaginatedResponseExecutionSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    status: ExecutionStatus | None | Unset = UNSET,
+    action_ref: None | str | Unset = UNSET,
+    pack_name: None | str | Unset = UNSET,
+    result_contains: None | str | Unset = UNSET,
+    enforcement: int | None | Unset = UNSET,
+    parent: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    json_status: None | str | Unset
+    if isinstance(status, Unset):
+        json_status = UNSET
+    elif isinstance(status, ExecutionStatus):
+        json_status = status.value
+    else:
+        json_status = status
+    params["status"] = json_status
+
+    json_action_ref: None | str | Unset
+    if isinstance(action_ref, Unset):
+        json_action_ref = UNSET
+    else:
+        json_action_ref = action_ref
+    params["action_ref"] = json_action_ref
+
+    json_pack_name: None | str | Unset
+    if isinstance(pack_name, Unset):
+        json_pack_name = UNSET
+    else:
+        json_pack_name = pack_name
+    params["pack_name"] = json_pack_name
+
+    json_result_contains: None | str | Unset
+    if isinstance(result_contains, Unset):
+        json_result_contains = UNSET
+    else:
+        json_result_contains = result_contains
+    params["result_contains"] = json_result_contains
+
+    json_enforcement: int | None | Unset
+    if isinstance(enforcement, Unset):
+        json_enforcement = UNSET
+    else:
+        json_enforcement = enforcement
+    params["enforcement"] = json_enforcement
+
+    json_parent: int | None | Unset
+    if isinstance(parent, Unset):
+        json_parent = UNSET
+    else:
+        json_parent = parent
+    params["parent"] = json_parent
+
+    params["page"] = page
+
+    params["per_page"] = per_page
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/executions",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> PaginatedResponseExecutionSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseExecutionSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[PaginatedResponseExecutionSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    status: ExecutionStatus | None | Unset = UNSET,
+    action_ref: None | str | Unset = UNSET,
+    pack_name: None | str | Unset = UNSET,
+    result_contains: None | str | Unset = UNSET,
+    enforcement: int | None | Unset = UNSET,
+    parent: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[PaginatedResponseExecutionSummary]:
+    """ List all executions with pagination and optional filters
+
+    Args:
+        status (ExecutionStatus | None | Unset):
+        action_ref (None | str | Unset):
+        pack_name (None | str | Unset):
+        result_contains (None | str | Unset):
+        enforcement (int | None | Unset):
+        parent (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponseExecutionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+action_ref=action_ref,
+pack_name=pack_name,
+result_contains=result_contains,
+enforcement=enforcement,
+parent=parent,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    status: ExecutionStatus | None | Unset = UNSET,
+    action_ref: None | str | Unset = UNSET,
+    pack_name: None | str | Unset = UNSET,
+    result_contains: None | str | Unset = UNSET,
+    enforcement: int | None | Unset = UNSET,
+    parent: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> PaginatedResponseExecutionSummary | None:
+    """ List all executions with pagination and optional filters
+
+    Args:
+        status (ExecutionStatus | None | Unset):
+        action_ref (None | str | Unset):
+        pack_name (None | str | Unset):
+        result_contains (None | str | Unset):
+        enforcement (int | None | Unset):
+        parent (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponseExecutionSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+status=status,
+action_ref=action_ref,
+pack_name=pack_name,
+result_contains=result_contains,
+enforcement=enforcement,
+parent=parent,
+page=page,
+per_page=per_page,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    status: ExecutionStatus | None | Unset = UNSET,
+    action_ref: None | str | Unset = UNSET,
+    pack_name: None | str | Unset = UNSET,
+    result_contains: None | str | Unset = UNSET,
+    enforcement: int | None | Unset = UNSET,
+    parent: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[PaginatedResponseExecutionSummary]:
+    """ List all executions with pagination and optional filters
+
+    Args:
+        status (ExecutionStatus | None | Unset):
+        action_ref (None | str | Unset):
+        pack_name (None | str | Unset):
+        result_contains (None | str | Unset):
+        enforcement (int | None | Unset):
+        parent (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponseExecutionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+action_ref=action_ref,
+pack_name=pack_name,
+result_contains=result_contains,
+enforcement=enforcement,
+parent=parent,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    status: ExecutionStatus | None | Unset = UNSET,
+    action_ref: None | str | Unset = UNSET,
+    pack_name: None | str | Unset = UNSET,
+    result_contains: None | str | Unset = UNSET,
+    enforcement: int | None | Unset = UNSET,
+    parent: int | None | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> PaginatedResponseExecutionSummary | None:
+    """ List all executions with pagination and optional filters
+
+    Args:
+        status (ExecutionStatus | None | Unset):
+        action_ref (None | str | Unset):
+        pack_name (None | str | Unset):
+        result_contains (None | str | Unset):
+        enforcement (int | None | Unset):
+        parent (int | None | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponseExecutionSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+status=status,
+action_ref=action_ref,
+pack_name=pack_name,
+result_contains=result_contains,
+enforcement=enforcement,
+parent=parent,
+page=page,
+per_page=per_page,
+
+    )).parsed

tests/generated_client/api/executions/list_executions_by_enforcement.py

@@ -0,0 +1,212 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_execution_summary import PaginatedResponseExecutionSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    enforcement_id: int,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/executions/enforcement/{enforcement_id}".format(enforcement_id=quote(str(enforcement_id), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseExecutionSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseExecutionSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseExecutionSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    enforcement_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseExecutionSummary]:
+    """ List executions by enforcement ID
+
+    Args:
+        enforcement_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseExecutionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        enforcement_id=enforcement_id,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    enforcement_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseExecutionSummary | None:
+    """ List executions by enforcement ID
+
+    Args:
+        enforcement_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseExecutionSummary
+     """
+
+
+    return sync_detailed(
+        enforcement_id=enforcement_id,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    enforcement_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseExecutionSummary]:
+    """ List executions by enforcement ID
+
+    Args:
+        enforcement_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseExecutionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        enforcement_id=enforcement_id,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    enforcement_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseExecutionSummary | None:
+    """ List executions by enforcement ID
+
+    Args:
+        enforcement_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseExecutionSummary
+     """
+
+
+    return (await asyncio_detailed(
+        enforcement_id=enforcement_id,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/executions/list_executions_by_status.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_execution_summary import PaginatedResponseExecutionSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    status: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/executions/status/{status}".format(status=quote(str(status), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseExecutionSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseExecutionSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseExecutionSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseExecutionSummary]:
+    """ List executions by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseExecutionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseExecutionSummary | None:
+    """ List executions by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseExecutionSummary
+     """
+
+
+    return sync_detailed(
+        status=status,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseExecutionSummary]:
+    """ List executions by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseExecutionSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseExecutionSummary | None:
+    """ List executions by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseExecutionSummary
+     """
+
+
+    return (await asyncio_detailed(
+        status=status,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/health/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/health/health.py

@@ -0,0 +1,158 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.health_response_200 import HealthResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/health",
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> HealthResponse200 | None:
+    if response.status_code == 200:
+        response_200 = HealthResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[HealthResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[HealthResponse200]:
+    """ Basic health check endpoint
+
+     Returns 200 OK if the service is running
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[HealthResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> HealthResponse200 | None:
+    """ Basic health check endpoint
+
+     Returns 200 OK if the service is running
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        HealthResponse200
+     """
+
+
+    return sync_detailed(
+        client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[HealthResponse200]:
+    """ Basic health check endpoint
+
+     Returns 200 OK if the service is running
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[HealthResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> HealthResponse200 | None:
+    """ Basic health check endpoint
+
+     Returns 200 OK if the service is running
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        HealthResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+
+    )).parsed

tests/generated_client/api/health/health_detailed.py

@@ -0,0 +1,166 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.health_detailed_response_503 import HealthDetailedResponse503
+from ...models.health_response import HealthResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/health/detailed",
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> HealthDetailedResponse503 | HealthResponse | None:
+    if response.status_code == 200:
+        response_200 = HealthResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 503:
+        response_503 = HealthDetailedResponse503.from_dict(response.json())
+
+
+
+        return response_503
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[HealthDetailedResponse503 | HealthResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[HealthDetailedResponse503 | HealthResponse]:
+    """ Detailed health check endpoint
+
+     Checks database connectivity and returns detailed status
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[HealthDetailedResponse503 | HealthResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> HealthDetailedResponse503 | HealthResponse | None:
+    """ Detailed health check endpoint
+
+     Checks database connectivity and returns detailed status
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        HealthDetailedResponse503 | HealthResponse
+     """
+
+
+    return sync_detailed(
+        client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[HealthDetailedResponse503 | HealthResponse]:
+    """ Detailed health check endpoint
+
+     Checks database connectivity and returns detailed status
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[HealthDetailedResponse503 | HealthResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> HealthDetailedResponse503 | HealthResponse | None:
+    """ Detailed health check endpoint
+
+     Checks database connectivity and returns detailed status
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        HealthDetailedResponse503 | HealthResponse
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+
+    )).parsed

tests/generated_client/api/health/liveness.py

@@ -0,0 +1,108 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+
+
+
+def _get_kwargs(
+    
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/health/live",
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | None:
+    if response.status_code == 200:
+        return None
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any]:
+    """ Liveness check endpoint
+
+     Returns 200 OK if the service process is alive
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any]:
+    """ Liveness check endpoint
+
+     Returns 200 OK if the service process is alive
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+

tests/generated_client/api/health/readiness.py

@@ -0,0 +1,111 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+
+
+
+def _get_kwargs(
+    
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/health/ready",
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | None:
+    if response.status_code == 200:
+        return None
+
+    if response.status_code == 503:
+        return None
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any]:
+    """ Readiness check endpoint
+
+     Returns 200 OK if the service is ready to accept requests
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any]:
+    """ Readiness check endpoint
+
+     Returns 200 OK if the service is ready to accept requests
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+     """
+
+
+    kwargs = _get_kwargs(
+        
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+

tests/generated_client/api/inquiries/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/inquiries/create_inquiry.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_inquiry_response import ApiResponseInquiryResponse
+from ...models.create_inquiry_request import CreateInquiryRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateInquiryRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/inquiries",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseInquiryResponse | None:
+    if response.status_code == 201:
+        response_201 = ApiResponseInquiryResponse.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseInquiryResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateInquiryRequest,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Create a new inquiry
+
+    Args:
+        body (CreateInquiryRequest): Request to create a new inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: CreateInquiryRequest,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Create a new inquiry
+
+    Args:
+        body (CreateInquiryRequest): Request to create a new inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateInquiryRequest,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Create a new inquiry
+
+    Args:
+        body (CreateInquiryRequest): Request to create a new inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: CreateInquiryRequest,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Create a new inquiry
+
+    Args:
+        body (CreateInquiryRequest): Request to create a new inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/inquiries/delete_inquiry.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/inquiries/{id}".format(id=quote(str(id), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete an inquiry
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete an inquiry
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete an inquiry
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete an inquiry
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+
+    )).parsed

tests/generated_client/api/inquiries/get_inquiry.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_inquiry_response import ApiResponseInquiryResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/inquiries/{id}".format(id=quote(str(id), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseInquiryResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseInquiryResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseInquiryResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Get a single inquiry by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Get a single inquiry by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Get a single inquiry by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Get a single inquiry by ID
+
+    Args:
+        id (int):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+
+    )).parsed

tests/generated_client/api/inquiries/list_inquiries.py

@@ -0,0 +1,276 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.inquiry_status import InquiryStatus
+from ...models.paginated_response_inquiry_summary import PaginatedResponseInquirySummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    status: InquiryStatus | None | Unset = UNSET,
+    execution: int | None | Unset = UNSET,
+    assigned_to: int | None | Unset = UNSET,
+    offset: int | None | Unset = UNSET,
+    limit: int | None | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    json_status: None | str | Unset
+    if isinstance(status, Unset):
+        json_status = UNSET
+    elif isinstance(status, InquiryStatus):
+        json_status = status.value
+    else:
+        json_status = status
+    params["status"] = json_status
+
+    json_execution: int | None | Unset
+    if isinstance(execution, Unset):
+        json_execution = UNSET
+    else:
+        json_execution = execution
+    params["execution"] = json_execution
+
+    json_assigned_to: int | None | Unset
+    if isinstance(assigned_to, Unset):
+        json_assigned_to = UNSET
+    else:
+        json_assigned_to = assigned_to
+    params["assigned_to"] = json_assigned_to
+
+    json_offset: int | None | Unset
+    if isinstance(offset, Unset):
+        json_offset = UNSET
+    else:
+        json_offset = offset
+    params["offset"] = json_offset
+
+    json_limit: int | None | Unset
+    if isinstance(limit, Unset):
+        json_limit = UNSET
+    else:
+        json_limit = limit
+    params["limit"] = json_limit
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/inquiries",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseInquirySummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseInquirySummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseInquirySummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    status: InquiryStatus | None | Unset = UNSET,
+    execution: int | None | Unset = UNSET,
+    assigned_to: int | None | Unset = UNSET,
+    offset: int | None | Unset = UNSET,
+    limit: int | None | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseInquirySummary]:
+    """ List all inquiries with pagination and optional filters
+
+    Args:
+        status (InquiryStatus | None | Unset):
+        execution (int | None | Unset):
+        assigned_to (int | None | Unset):
+        offset (int | None | Unset):
+        limit (int | None | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseInquirySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+execution=execution,
+assigned_to=assigned_to,
+offset=offset,
+limit=limit,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    status: InquiryStatus | None | Unset = UNSET,
+    execution: int | None | Unset = UNSET,
+    assigned_to: int | None | Unset = UNSET,
+    offset: int | None | Unset = UNSET,
+    limit: int | None | Unset = UNSET,
+
+) -> Any | PaginatedResponseInquirySummary | None:
+    """ List all inquiries with pagination and optional filters
+
+    Args:
+        status (InquiryStatus | None | Unset):
+        execution (int | None | Unset):
+        assigned_to (int | None | Unset):
+        offset (int | None | Unset):
+        limit (int | None | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseInquirySummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+status=status,
+execution=execution,
+assigned_to=assigned_to,
+offset=offset,
+limit=limit,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    status: InquiryStatus | None | Unset = UNSET,
+    execution: int | None | Unset = UNSET,
+    assigned_to: int | None | Unset = UNSET,
+    offset: int | None | Unset = UNSET,
+    limit: int | None | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseInquirySummary]:
+    """ List all inquiries with pagination and optional filters
+
+    Args:
+        status (InquiryStatus | None | Unset):
+        execution (int | None | Unset):
+        assigned_to (int | None | Unset):
+        offset (int | None | Unset):
+        limit (int | None | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseInquirySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+execution=execution,
+assigned_to=assigned_to,
+offset=offset,
+limit=limit,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    status: InquiryStatus | None | Unset = UNSET,
+    execution: int | None | Unset = UNSET,
+    assigned_to: int | None | Unset = UNSET,
+    offset: int | None | Unset = UNSET,
+    limit: int | None | Unset = UNSET,
+
+) -> Any | PaginatedResponseInquirySummary | None:
+    """ List all inquiries with pagination and optional filters
+
+    Args:
+        status (InquiryStatus | None | Unset):
+        execution (int | None | Unset):
+        assigned_to (int | None | Unset):
+        offset (int | None | Unset):
+        limit (int | None | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseInquirySummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+status=status,
+execution=execution,
+assigned_to=assigned_to,
+offset=offset,
+limit=limit,
+
+    )).parsed

tests/generated_client/api/inquiries/list_inquiries_by_execution.py

@@ -0,0 +1,220 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_inquiry_summary import PaginatedResponseInquirySummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    execution_id: int,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/executions/{execution_id}/inquiries".format(execution_id=quote(str(execution_id), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseInquirySummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseInquirySummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseInquirySummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    execution_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseInquirySummary]:
+    """ List inquiries for a specific execution
+
+    Args:
+        execution_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseInquirySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        execution_id=execution_id,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    execution_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseInquirySummary | None:
+    """ List inquiries for a specific execution
+
+    Args:
+        execution_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseInquirySummary
+     """
+
+
+    return sync_detailed(
+        execution_id=execution_id,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    execution_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseInquirySummary]:
+    """ List inquiries for a specific execution
+
+    Args:
+        execution_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseInquirySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        execution_id=execution_id,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    execution_id: int,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseInquirySummary | None:
+    """ List inquiries for a specific execution
+
+    Args:
+        execution_id (int):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseInquirySummary
+     """
+
+
+    return (await asyncio_detailed(
+        execution_id=execution_id,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/inquiries/list_inquiries_by_status.py

@@ -0,0 +1,220 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_inquiry_summary import PaginatedResponseInquirySummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    status: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/inquiries/status/{status}".format(status=quote(str(status), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseInquirySummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseInquirySummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseInquirySummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseInquirySummary]:
+    """ List inquiries by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseInquirySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseInquirySummary | None:
+    """ List inquiries by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseInquirySummary
+     """
+
+
+    return sync_detailed(
+        status=status,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseInquirySummary]:
+    """ List inquiries by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseInquirySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        status=status,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    status: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseInquirySummary | None:
+    """ List inquiries by status
+
+    Args:
+        status (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseInquirySummary
+     """
+
+
+    return (await asyncio_detailed(
+        status=status,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/inquiries/respond_to_inquiry.py

@@ -0,0 +1,212 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_inquiry_response import ApiResponseInquiryResponse
+from ...models.inquiry_respond_request import InquiryRespondRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+    *,
+    body: InquiryRespondRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/inquiries/{id}/respond".format(id=quote(str(id), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseInquiryResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseInquiryResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 403:
+        response_403 = cast(Any, None)
+        return response_403
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseInquiryResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: InquiryRespondRequest,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Respond to an inquiry (user-facing endpoint)
+
+    Args:
+        id (int):
+        body (InquiryRespondRequest): Request to respond to an inquiry (user-facing endpoint)
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: InquiryRespondRequest,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Respond to an inquiry (user-facing endpoint)
+
+    Args:
+        id (int):
+        body (InquiryRespondRequest): Request to respond to an inquiry (user-facing endpoint)
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: InquiryRespondRequest,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Respond to an inquiry (user-facing endpoint)
+
+    Args:
+        id (int):
+        body (InquiryRespondRequest): Request to respond to an inquiry (user-facing endpoint)
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: InquiryRespondRequest,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Respond to an inquiry (user-facing endpoint)
+
+    Args:
+        id (int):
+        body (InquiryRespondRequest): Request to respond to an inquiry (user-facing endpoint)
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/inquiries/update_inquiry.py

@@ -0,0 +1,208 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_inquiry_response import ApiResponseInquiryResponse
+from ...models.update_inquiry_request import UpdateInquiryRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    id: int,
+    *,
+    body: UpdateInquiryRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/inquiries/{id}".format(id=quote(str(id), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseInquiryResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseInquiryResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = cast(Any, None)
+        return response_401
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseInquiryResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateInquiryRequest,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Update an existing inquiry
+
+    Args:
+        id (int):
+        body (UpdateInquiryRequest): Request to update an inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateInquiryRequest,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Update an existing inquiry
+
+    Args:
+        id (int):
+        body (UpdateInquiryRequest): Request to update an inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return sync_detailed(
+        id=id,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateInquiryRequest,
+
+) -> Response[Any | ApiResponseInquiryResponse]:
+    """ Update an existing inquiry
+
+    Args:
+        id (int):
+        body (UpdateInquiryRequest): Request to update an inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseInquiryResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        id=id,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    id: int,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateInquiryRequest,
+
+) -> Any | ApiResponseInquiryResponse | None:
+    """ Update an existing inquiry
+
+    Args:
+        id (int):
+        body (UpdateInquiryRequest): Request to update an inquiry
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseInquiryResponse
+     """
+
+
+    return (await asyncio_detailed(
+        id=id,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/packs/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/packs/create_pack.py

@@ -0,0 +1,187 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.create_pack_request import CreatePackRequest
+from ...models.create_pack_response_201 import CreatePackResponse201
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreatePackRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/packs",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | CreatePackResponse201 | None:
+    if response.status_code == 201:
+        response_201 = CreatePackResponse201.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | CreatePackResponse201]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreatePackRequest,
+
+) -> Response[Any | CreatePackResponse201]:
+    """ Create a new pack
+
+    Args:
+        body (CreatePackRequest): Request DTO for creating a new pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreatePackResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: CreatePackRequest,
+
+) -> Any | CreatePackResponse201 | None:
+    """ Create a new pack
+
+    Args:
+        body (CreatePackRequest): Request DTO for creating a new pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreatePackResponse201
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreatePackRequest,
+
+) -> Response[Any | CreatePackResponse201]:
+    """ Create a new pack
+
+    Args:
+        body (CreatePackRequest): Request DTO for creating a new pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreatePackResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: CreatePackRequest,
+
+) -> Any | CreatePackResponse201 | None:
+    """ Create a new pack
+
+    Args:
+        body (CreatePackRequest): Request DTO for creating a new pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreatePackResponse201
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/packs/delete_pack.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/packs/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/packs/get_pack.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_pack_response_200 import GetPackResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetPackResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetPackResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetPackResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetPackResponse200]:
+    """ Get a single pack by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetPackResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetPackResponse200 | None:
+    """ Get a single pack by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetPackResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetPackResponse200]:
+    """ Get a single pack by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetPackResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetPackResponse200 | None:
+    """ Get a single pack by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetPackResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/packs/get_pack_latest_test.py

@@ -0,0 +1,118 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{ref}/tests/latest".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | None:
+    if response.status_code == 200:
+        return None
+
+    if response.status_code == 404:
+        return None
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any]:
+    """ Get latest test result for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any]:
+    """ Get latest test result for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+

tests/generated_client/api/packs/get_pack_test_history.py

@@ -0,0 +1,212 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_pack_test_history_response_200 import GetPackTestHistoryResponse200
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{ref}/tests".format(ref=quote(str(ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetPackTestHistoryResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetPackTestHistoryResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetPackTestHistoryResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | GetPackTestHistoryResponse200]:
+    """ Get test history for a pack
+
+    Args:
+        ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetPackTestHistoryResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | GetPackTestHistoryResponse200 | None:
+    """ Get test history for a pack
+
+    Args:
+        ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetPackTestHistoryResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | GetPackTestHistoryResponse200]:
+    """ Get test history for a pack
+
+    Args:
+        ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetPackTestHistoryResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | GetPackTestHistoryResponse200 | None:
+    """ Get test history for a pack
+
+    Args:
+        ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetPackTestHistoryResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/packs/install_pack.py

@@ -0,0 +1,201 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_pack_install_response import ApiResponsePackInstallResponse
+from ...models.api_response_string import ApiResponseString
+from ...models.install_pack_request import InstallPackRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: InstallPackRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/packs/install",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> ApiResponsePackInstallResponse | ApiResponseString | None:
+    if response.status_code == 201:
+        response_201 = ApiResponsePackInstallResponse.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = ApiResponseString.from_dict(response.json())
+
+
+
+        return response_400
+
+    if response.status_code == 409:
+        response_409 = ApiResponseString.from_dict(response.json())
+
+
+
+        return response_409
+
+    if response.status_code == 501:
+        response_501 = ApiResponseString.from_dict(response.json())
+
+
+
+        return response_501
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[ApiResponsePackInstallResponse | ApiResponseString]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: InstallPackRequest,
+
+) -> Response[ApiResponsePackInstallResponse | ApiResponseString]:
+    """ Install a pack from remote source (git repository)
+
+    Args:
+        body (InstallPackRequest): Request DTO for installing a pack from remote source
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiResponsePackInstallResponse | ApiResponseString]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: InstallPackRequest,
+
+) -> ApiResponsePackInstallResponse | ApiResponseString | None:
+    """ Install a pack from remote source (git repository)
+
+    Args:
+        body (InstallPackRequest): Request DTO for installing a pack from remote source
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiResponsePackInstallResponse | ApiResponseString
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: InstallPackRequest,
+
+) -> Response[ApiResponsePackInstallResponse | ApiResponseString]:
+    """ Install a pack from remote source (git repository)
+
+    Args:
+        body (InstallPackRequest): Request DTO for installing a pack from remote source
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiResponsePackInstallResponse | ApiResponseString]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: InstallPackRequest,
+
+) -> ApiResponsePackInstallResponse | ApiResponseString | None:
+    """ Install a pack from remote source (git repository)
+
+    Args:
+        body (InstallPackRequest): Request DTO for installing a pack from remote source
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiResponsePackInstallResponse | ApiResponseString
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/packs/list_packs.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_pack_summary import PaginatedResponsePackSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> PaginatedResponsePackSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponsePackSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[PaginatedResponsePackSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[PaginatedResponsePackSummary]:
+    """ List all packs with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponsePackSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> PaginatedResponsePackSummary | None:
+    """ List all packs with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponsePackSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[PaginatedResponsePackSummary]:
+    """ List all packs with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponsePackSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> PaginatedResponsePackSummary | None:
+    """ List all packs with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponsePackSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/packs/register_pack.py

@@ -0,0 +1,194 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_pack_install_response import ApiResponsePackInstallResponse
+from ...models.api_response_string import ApiResponseString
+from ...models.register_pack_request import RegisterPackRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: RegisterPackRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/packs/register",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> ApiResponsePackInstallResponse | ApiResponseString | None:
+    if response.status_code == 201:
+        response_201 = ApiResponsePackInstallResponse.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = ApiResponseString.from_dict(response.json())
+
+
+
+        return response_400
+
+    if response.status_code == 409:
+        response_409 = ApiResponseString.from_dict(response.json())
+
+
+
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[ApiResponsePackInstallResponse | ApiResponseString]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: RegisterPackRequest,
+
+) -> Response[ApiResponsePackInstallResponse | ApiResponseString]:
+    """ Register a pack from local filesystem
+
+    Args:
+        body (RegisterPackRequest): Request DTO for registering a pack from local filesystem
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiResponsePackInstallResponse | ApiResponseString]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: RegisterPackRequest,
+
+) -> ApiResponsePackInstallResponse | ApiResponseString | None:
+    """ Register a pack from local filesystem
+
+    Args:
+        body (RegisterPackRequest): Request DTO for registering a pack from local filesystem
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiResponsePackInstallResponse | ApiResponseString
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: RegisterPackRequest,
+
+) -> Response[ApiResponsePackInstallResponse | ApiResponseString]:
+    """ Register a pack from local filesystem
+
+    Args:
+        body (RegisterPackRequest): Request DTO for registering a pack from local filesystem
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[ApiResponsePackInstallResponse | ApiResponseString]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: RegisterPackRequest,
+
+) -> ApiResponsePackInstallResponse | ApiResponseString | None:
+    """ Register a pack from local filesystem
+
+    Args:
+        body (RegisterPackRequest): Request DTO for registering a pack from local filesystem
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        ApiResponsePackInstallResponse | ApiResponseString
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/packs/sync_pack_workflows.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.sync_pack_workflows_response_200 import SyncPackWorkflowsResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/packs/{ref}/workflows/sync".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SyncPackWorkflowsResponse200 | None:
+    if response.status_code == 200:
+        response_200 = SyncPackWorkflowsResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SyncPackWorkflowsResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SyncPackWorkflowsResponse200]:
+    """ Sync workflows from filesystem to database for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SyncPackWorkflowsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SyncPackWorkflowsResponse200 | None:
+    """ Sync workflows from filesystem to database for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SyncPackWorkflowsResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SyncPackWorkflowsResponse200]:
+    """ Sync workflows from filesystem to database for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SyncPackWorkflowsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SyncPackWorkflowsResponse200 | None:
+    """ Sync workflows from filesystem to database for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SyncPackWorkflowsResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/packs/test_pack.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.test_pack_response_200 import TestPackResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/packs/{ref}/test".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | TestPackResponse200 | None:
+    if response.status_code == 200:
+        response_200 = TestPackResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | TestPackResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TestPackResponse200]:
+    """ Execute tests for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TestPackResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TestPackResponse200 | None:
+    """ Execute tests for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TestPackResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TestPackResponse200]:
+    """ Execute tests for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TestPackResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TestPackResponse200 | None:
+    """ Execute tests for a pack
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TestPackResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/packs/update_pack.py

@@ -0,0 +1,200 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.update_pack_request import UpdatePackRequest
+from ...models.update_pack_response_200 import UpdatePackResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    body: UpdatePackRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/packs/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | UpdatePackResponse200 | None:
+    if response.status_code == 200:
+        response_200 = UpdatePackResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | UpdatePackResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdatePackRequest,
+
+) -> Response[Any | UpdatePackResponse200]:
+    """ Update an existing pack
+
+    Args:
+        ref (str):
+        body (UpdatePackRequest): Request DTO for updating a pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | UpdatePackResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdatePackRequest,
+
+) -> Any | UpdatePackResponse200 | None:
+    """ Update an existing pack
+
+    Args:
+        ref (str):
+        body (UpdatePackRequest): Request DTO for updating a pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | UpdatePackResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdatePackRequest,
+
+) -> Response[Any | UpdatePackResponse200]:
+    """ Update an existing pack
+
+    Args:
+        ref (str):
+        body (UpdatePackRequest): Request DTO for updating a pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | UpdatePackResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdatePackRequest,
+
+) -> Any | UpdatePackResponse200 | None:
+    """ Update an existing pack
+
+    Args:
+        ref (str):
+        body (UpdatePackRequest): Request DTO for updating a pack
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | UpdatePackResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/packs/validate_pack_workflows.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.validate_pack_workflows_response_200 import ValidatePackWorkflowsResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/packs/{ref}/workflows/validate".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ValidatePackWorkflowsResponse200 | None:
+    if response.status_code == 200:
+        response_200 = ValidatePackWorkflowsResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ValidatePackWorkflowsResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ValidatePackWorkflowsResponse200]:
+    """ Validate workflows for a pack without syncing
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ValidatePackWorkflowsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ValidatePackWorkflowsResponse200 | None:
+    """ Validate workflows for a pack without syncing
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ValidatePackWorkflowsResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | ValidatePackWorkflowsResponse200]:
+    """ Validate workflows for a pack without syncing
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ValidatePackWorkflowsResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | ValidatePackWorkflowsResponse200 | None:
+    """ Validate workflows for a pack without syncing
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ValidatePackWorkflowsResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/rules/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/rules/create_rule.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_rule_response import ApiResponseRuleResponse
+from ...models.create_rule_request import CreateRuleRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateRuleRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/rules",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseRuleResponse | None:
+    if response.status_code == 201:
+        response_201 = ApiResponseRuleResponse.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseRuleResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateRuleRequest,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Create a new rule
+
+    Args:
+        body (CreateRuleRequest): Request DTO for creating a new rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateRuleRequest,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Create a new rule
+
+    Args:
+        body (CreateRuleRequest): Request DTO for creating a new rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateRuleRequest,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Create a new rule
+
+    Args:
+        body (CreateRuleRequest): Request DTO for creating a new rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateRuleRequest,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Create a new rule
+
+    Args:
+        body (CreateRuleRequest): Request DTO for creating a new rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/rules/delete_rule.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/rules/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/rules/disable_rule.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_rule_response import ApiResponseRuleResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/rules/{ref}/disable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseRuleResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseRuleResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseRuleResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Disable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Disable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Disable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Disable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/rules/enable_rule.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_rule_response import ApiResponseRuleResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/rules/{ref}/enable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseRuleResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseRuleResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseRuleResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Enable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Enable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Enable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Enable a rule
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/rules/get_rule.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_rule_response import ApiResponseRuleResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/rules/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseRuleResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseRuleResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseRuleResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Get a single rule by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Get a single rule by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Get a single rule by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Get a single rule by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/rules/list_enabled_rules.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_rule_summary import PaginatedResponseRuleSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/rules/enabled",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseRuleSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseRuleSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseRuleSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List enabled rules
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List enabled rules
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List enabled rules
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List enabled rules
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/rules/list_rules.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_rule_summary import PaginatedResponseRuleSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/rules",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseRuleSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseRuleSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseRuleSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List all rules with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List all rules with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List all rules with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List all rules with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/rules/list_rules_by_action.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_rule_summary import PaginatedResponseRuleSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    action_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/actions/{action_ref}/rules".format(action_ref=quote(str(action_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseRuleSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseRuleSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseRuleSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    action_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List rules by action reference
+
+    Args:
+        action_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        action_ref=action_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    action_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List rules by action reference
+
+    Args:
+        action_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return sync_detailed(
+        action_ref=action_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    action_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List rules by action reference
+
+    Args:
+        action_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        action_ref=action_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    action_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List rules by action reference
+
+    Args:
+        action_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return (await asyncio_detailed(
+        action_ref=action_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/rules/list_rules_by_pack.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_rule_summary import PaginatedResponseRuleSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    pack_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{pack_ref}/rules".format(pack_ref=quote(str(pack_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseRuleSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseRuleSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseRuleSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List rules by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List rules by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return sync_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List rules by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List rules by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return (await asyncio_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/rules/list_rules_by_trigger.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_rule_summary import PaginatedResponseRuleSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    trigger_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/triggers/{trigger_ref}/rules".format(trigger_ref=quote(str(trigger_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseRuleSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseRuleSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseRuleSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List rules by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        trigger_ref=trigger_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List rules by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return sync_detailed(
+        trigger_ref=trigger_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseRuleSummary]:
+    """ List rules by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseRuleSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        trigger_ref=trigger_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseRuleSummary | None:
+    """ List rules by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseRuleSummary
+     """
+
+
+    return (await asyncio_detailed(
+        trigger_ref=trigger_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/rules/update_rule.py

@@ -0,0 +1,204 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_rule_response import ApiResponseRuleResponse
+from ...models.update_rule_request import UpdateRuleRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    body: UpdateRuleRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/rules/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseRuleResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseRuleResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseRuleResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateRuleRequest,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Update an existing rule
+
+    Args:
+        ref (str):
+        body (UpdateRuleRequest): Request DTO for updating a rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateRuleRequest,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Update an existing rule
+
+    Args:
+        ref (str):
+        body (UpdateRuleRequest): Request DTO for updating a rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateRuleRequest,
+
+) -> Response[Any | ApiResponseRuleResponse]:
+    """ Update an existing rule
+
+    Args:
+        ref (str):
+        body (UpdateRuleRequest): Request DTO for updating a rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseRuleResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateRuleRequest,
+
+) -> Any | ApiResponseRuleResponse | None:
+    """ Update an existing rule
+
+    Args:
+        ref (str):
+        body (UpdateRuleRequest): Request DTO for updating a rule
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseRuleResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/secrets/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/secrets/create_key.py

@@ -0,0 +1,187 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.create_key_request import CreateKeyRequest
+from ...models.create_key_response_201 import CreateKeyResponse201
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateKeyRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/keys",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | CreateKeyResponse201 | None:
+    if response.status_code == 201:
+        response_201 = CreateKeyResponse201.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | CreateKeyResponse201]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateKeyRequest,
+
+) -> Response[Any | CreateKeyResponse201]:
+    """ Create a new key/secret
+
+    Args:
+        body (CreateKeyRequest): Request to create a new key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreateKeyResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: CreateKeyRequest,
+
+) -> Any | CreateKeyResponse201 | None:
+    """ Create a new key/secret
+
+    Args:
+        body (CreateKeyRequest): Request to create a new key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreateKeyResponse201
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateKeyRequest,
+
+) -> Response[Any | CreateKeyResponse201]:
+    """ Create a new key/secret
+
+    Args:
+        body (CreateKeyRequest): Request to create a new key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreateKeyResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: CreateKeyRequest,
+
+) -> Any | CreateKeyResponse201 | None:
+    """ Create a new key/secret
+
+    Args:
+        body (CreateKeyRequest): Request to create a new key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreateKeyResponse201
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/secrets/delete_key.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/keys/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a key/secret
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a key/secret
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a key/secret
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a key/secret
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/secrets/get_key.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.get_key_response_200 import GetKeyResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/keys/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | GetKeyResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetKeyResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | GetKeyResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetKeyResponse200]:
+    """ Get a single key by reference (includes decrypted value)
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetKeyResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetKeyResponse200 | None:
+    """ Get a single key by reference (includes decrypted value)
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetKeyResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | GetKeyResponse200]:
+    """ Get a single key by reference (includes decrypted value)
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetKeyResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | GetKeyResponse200 | None:
+    """ Get a single key by reference (includes decrypted value)
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetKeyResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/secrets/list_keys.py

@@ -0,0 +1,238 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.owner_type import OwnerType
+from ...models.paginated_response_key_summary import PaginatedResponseKeySummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    owner_type: None | OwnerType | Unset = UNSET,
+    owner: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    json_owner_type: None | str | Unset
+    if isinstance(owner_type, Unset):
+        json_owner_type = UNSET
+    elif isinstance(owner_type, OwnerType):
+        json_owner_type = owner_type.value
+    else:
+        json_owner_type = owner_type
+    params["owner_type"] = json_owner_type
+
+    json_owner: None | str | Unset
+    if isinstance(owner, Unset):
+        json_owner = UNSET
+    else:
+        json_owner = owner
+    params["owner"] = json_owner
+
+    params["page"] = page
+
+    params["per_page"] = per_page
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/keys",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> PaginatedResponseKeySummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseKeySummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[PaginatedResponseKeySummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    owner_type: None | OwnerType | Unset = UNSET,
+    owner: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[PaginatedResponseKeySummary]:
+    """ List all keys with pagination and optional filters (values redacted)
+
+    Args:
+        owner_type (None | OwnerType | Unset):
+        owner (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponseKeySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        owner_type=owner_type,
+owner=owner,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    owner_type: None | OwnerType | Unset = UNSET,
+    owner: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> PaginatedResponseKeySummary | None:
+    """ List all keys with pagination and optional filters (values redacted)
+
+    Args:
+        owner_type (None | OwnerType | Unset):
+        owner (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponseKeySummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+owner_type=owner_type,
+owner=owner,
+page=page,
+per_page=per_page,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    owner_type: None | OwnerType | Unset = UNSET,
+    owner: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> Response[PaginatedResponseKeySummary]:
+    """ List all keys with pagination and optional filters (values redacted)
+
+    Args:
+        owner_type (None | OwnerType | Unset):
+        owner (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[PaginatedResponseKeySummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        owner_type=owner_type,
+owner=owner,
+page=page,
+per_page=per_page,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    owner_type: None | OwnerType | Unset = UNSET,
+    owner: None | str | Unset = UNSET,
+    page: int | Unset = UNSET,
+    per_page: int | Unset = UNSET,
+
+) -> PaginatedResponseKeySummary | None:
+    """ List all keys with pagination and optional filters (values redacted)
+
+    Args:
+        owner_type (None | OwnerType | Unset):
+        owner (None | str | Unset):
+        page (int | Unset):
+        per_page (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        PaginatedResponseKeySummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+owner_type=owner_type,
+owner=owner,
+page=page,
+per_page=per_page,
+
+    )).parsed

tests/generated_client/api/secrets/update_key.py

@@ -0,0 +1,200 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.update_key_request import UpdateKeyRequest
+from ...models.update_key_response_200 import UpdateKeyResponse200
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    body: UpdateKeyRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/keys/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | UpdateKeyResponse200 | None:
+    if response.status_code == 200:
+        response_200 = UpdateKeyResponse200.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | UpdateKeyResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateKeyRequest,
+
+) -> Response[Any | UpdateKeyResponse200]:
+    """ Update an existing key/secret
+
+    Args:
+        ref (str):
+        body (UpdateKeyRequest): Request to update an existing key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | UpdateKeyResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateKeyRequest,
+
+) -> Any | UpdateKeyResponse200 | None:
+    """ Update an existing key/secret
+
+    Args:
+        ref (str):
+        body (UpdateKeyRequest): Request to update an existing key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | UpdateKeyResponse200
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateKeyRequest,
+
+) -> Response[Any | UpdateKeyResponse200]:
+    """ Update an existing key/secret
+
+    Args:
+        ref (str):
+        body (UpdateKeyRequest): Request to update an existing key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | UpdateKeyResponse200]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+    body: UpdateKeyRequest,
+
+) -> Any | UpdateKeyResponse200 | None:
+    """ Update an existing key/secret
+
+    Args:
+        ref (str):
+        body (UpdateKeyRequest): Request to update an existing key/secret
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | UpdateKeyResponse200
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/sensors/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/sensors/create_sensor.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_sensor_response import ApiResponseSensorResponse
+from ...models.create_sensor_request import CreateSensorRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateSensorRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/sensors",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseSensorResponse | None:
+    if response.status_code == 201:
+        response_201 = ApiResponseSensorResponse.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseSensorResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateSensorRequest,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Create a new sensor
+
+    Args:
+        body (CreateSensorRequest): Request DTO for creating a new sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateSensorRequest,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Create a new sensor
+
+    Args:
+        body (CreateSensorRequest): Request DTO for creating a new sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateSensorRequest,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Create a new sensor
+
+    Args:
+        body (CreateSensorRequest): Request DTO for creating a new sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateSensorRequest,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Create a new sensor
+
+    Args:
+        body (CreateSensorRequest): Request DTO for creating a new sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/sensors/delete_sensor.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/sensors/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/sensors/disable_sensor.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_sensor_response import ApiResponseSensorResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/sensors/{ref}/disable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseSensorResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseSensorResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseSensorResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Disable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Disable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Disable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Disable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/sensors/enable_sensor.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_sensor_response import ApiResponseSensorResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/sensors/{ref}/enable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseSensorResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseSensorResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseSensorResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Enable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Enable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Enable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Enable a sensor
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/sensors/get_sensor.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_sensor_response import ApiResponseSensorResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/sensors/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseSensorResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseSensorResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseSensorResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Get a single sensor by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Get a single sensor by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Get a single sensor by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Get a single sensor by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/sensors/list_enabled_sensors.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_sensor_summary import PaginatedResponseSensorSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/sensors/enabled",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseSensorSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseSensorSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseSensorSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List enabled sensors
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List enabled sensors
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List enabled sensors
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List enabled sensors
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/sensors/list_sensors.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_sensor_summary import PaginatedResponseSensorSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/sensors",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseSensorSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseSensorSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseSensorSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List all sensors with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List all sensors with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List all sensors with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List all sensors with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/sensors/list_sensors_by_pack.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_sensor_summary import PaginatedResponseSensorSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    pack_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{pack_ref}/sensors".format(pack_ref=quote(str(pack_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseSensorSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseSensorSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseSensorSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List sensors by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List sensors by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return sync_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List sensors by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List sensors by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return (await asyncio_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/sensors/list_sensors_by_trigger.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_sensor_summary import PaginatedResponseSensorSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    trigger_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/triggers/{trigger_ref}/sensors".format(trigger_ref=quote(str(trigger_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseSensorSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseSensorSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseSensorSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List sensors by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        trigger_ref=trigger_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List sensors by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return sync_detailed(
+        trigger_ref=trigger_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseSensorSummary]:
+    """ List sensors by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseSensorSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        trigger_ref=trigger_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    trigger_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseSensorSummary | None:
+    """ List sensors by trigger reference
+
+    Args:
+        trigger_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseSensorSummary
+     """
+
+
+    return (await asyncio_detailed(
+        trigger_ref=trigger_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/sensors/update_sensor.py

@@ -0,0 +1,204 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_sensor_response import ApiResponseSensorResponse
+from ...models.update_sensor_request import UpdateSensorRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    body: UpdateSensorRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/sensors/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseSensorResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseSensorResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseSensorResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateSensorRequest,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Update an existing sensor
+
+    Args:
+        ref (str):
+        body (UpdateSensorRequest): Request DTO for updating a sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateSensorRequest,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Update an existing sensor
+
+    Args:
+        ref (str):
+        body (UpdateSensorRequest): Request DTO for updating a sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateSensorRequest,
+
+) -> Response[Any | ApiResponseSensorResponse]:
+    """ Update an existing sensor
+
+    Args:
+        ref (str):
+        body (UpdateSensorRequest): Request DTO for updating a sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseSensorResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateSensorRequest,
+
+) -> Any | ApiResponseSensorResponse | None:
+    """ Update an existing sensor
+
+    Args:
+        ref (str):
+        body (UpdateSensorRequest): Request DTO for updating a sensor
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseSensorResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/triggers/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/triggers/create_trigger.py

@@ -0,0 +1,195 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_trigger_response import ApiResponseTriggerResponse
+from ...models.create_trigger_request import CreateTriggerRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateTriggerRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/triggers",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseTriggerResponse | None:
+    if response.status_code == 201:
+        response_201 = ApiResponseTriggerResponse.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseTriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateTriggerRequest,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Create a new trigger
+
+    Args:
+        body (CreateTriggerRequest): Request DTO for creating a new trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateTriggerRequest,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Create a new trigger
+
+    Args:
+        body (CreateTriggerRequest): Request DTO for creating a new trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateTriggerRequest,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Create a new trigger
+
+    Args:
+        body (CreateTriggerRequest): Request DTO for creating a new trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    body: CreateTriggerRequest,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Create a new trigger
+
+    Args:
+        body (CreateTriggerRequest): Request DTO for creating a new trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/triggers/delete_trigger.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.success_response import SuccessResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/triggers/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | SuccessResponse]:
+    """ Delete a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | SuccessResponse | None:
+    """ Delete a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/triggers/disable_trigger.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_trigger_response import ApiResponseTriggerResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/triggers/{ref}/disable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseTriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseTriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseTriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Disable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Disable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Disable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Disable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/triggers/enable_trigger.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_trigger_response import ApiResponseTriggerResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/triggers/{ref}/enable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseTriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseTriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseTriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Enable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Enable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Enable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Enable a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/triggers/get_trigger.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_trigger_response import ApiResponseTriggerResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/triggers/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseTriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseTriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseTriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Get a single trigger by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Get a single trigger by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Get a single trigger by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Get a single trigger by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/triggers/list_enabled_triggers.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_trigger_summary import PaginatedResponseTriggerSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/triggers/enabled",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseTriggerSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseTriggerSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseTriggerSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseTriggerSummary]:
+    """ List enabled triggers
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseTriggerSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseTriggerSummary | None:
+    """ List enabled triggers
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseTriggerSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseTriggerSummary]:
+    """ List enabled triggers
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseTriggerSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseTriggerSummary | None:
+    """ List enabled triggers
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseTriggerSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/triggers/list_triggers.py

@@ -0,0 +1,199 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_trigger_summary import PaginatedResponseTriggerSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/triggers",
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseTriggerSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseTriggerSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseTriggerSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseTriggerSummary]:
+    """ List all triggers with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseTriggerSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseTriggerSummary | None:
+    """ List all triggers with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseTriggerSummary
+     """
+
+
+    return sync_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseTriggerSummary]:
+    """ List all triggers with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseTriggerSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseTriggerSummary | None:
+    """ List all triggers with pagination
+
+    Args:
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseTriggerSummary
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/triggers/list_triggers_by_pack.py

@@ -0,0 +1,216 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.paginated_response_trigger_summary import PaginatedResponseTriggerSummary
+from ...types import UNSET, Unset
+from typing import cast
+
+
+
+def _get_kwargs(
+    pack_ref: str,
+    *,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    params: dict[str, Any] = {}
+
+    params["page"] = page
+
+    params["page_size"] = page_size
+
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/packs/{pack_ref}/triggers".format(pack_ref=quote(str(pack_ref), safe=""),),
+        "params": params,
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | PaginatedResponseTriggerSummary | None:
+    if response.status_code == 200:
+        response_200 = PaginatedResponseTriggerSummary.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | PaginatedResponseTriggerSummary]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseTriggerSummary]:
+    """ List triggers by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseTriggerSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseTriggerSummary | None:
+    """ List triggers by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseTriggerSummary
+     """
+
+
+    return sync_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    ).parsed
+
+async def asyncio_detailed(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Response[Any | PaginatedResponseTriggerSummary]:
+    """ List triggers by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | PaginatedResponseTriggerSummary]
+     """
+
+
+    kwargs = _get_kwargs(
+        pack_ref=pack_ref,
+page=page,
+page_size=page_size,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    pack_ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    page: int | Unset = UNSET,
+    page_size: int | Unset = UNSET,
+
+) -> Any | PaginatedResponseTriggerSummary | None:
+    """ List triggers by pack reference
+
+    Args:
+        pack_ref (str):
+        page (int | Unset):
+        page_size (int | Unset):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | PaginatedResponseTriggerSummary
+     """
+
+
+    return (await asyncio_detailed(
+        pack_ref=pack_ref,
+client=client,
+page=page,
+page_size=page_size,
+
+    )).parsed

tests/generated_client/api/triggers/update_trigger.py

@@ -0,0 +1,204 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.api_response_trigger_response import ApiResponseTriggerResponse
+from ...models.update_trigger_request import UpdateTriggerRequest
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+    *,
+    body: UpdateTriggerRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "put",
+        "url": "/api/v1/triggers/{ref}".format(ref=quote(str(ref), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | ApiResponseTriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = ApiResponseTriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | ApiResponseTriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateTriggerRequest,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Update an existing trigger
+
+    Args:
+        ref (str):
+        body (UpdateTriggerRequest): Request DTO for updating a trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateTriggerRequest,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Update an existing trigger
+
+    Args:
+        ref (str):
+        body (UpdateTriggerRequest): Request DTO for updating a trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateTriggerRequest,
+
+) -> Response[Any | ApiResponseTriggerResponse]:
+    """ Update an existing trigger
+
+    Args:
+        ref (str):
+        body (UpdateTriggerRequest): Request DTO for updating a trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | ApiResponseTriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: UpdateTriggerRequest,
+
+) -> Any | ApiResponseTriggerResponse | None:
+    """ Update an existing trigger
+
+    Args:
+        ref (str):
+        body (UpdateTriggerRequest): Request DTO for updating a trigger
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | ApiResponseTriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/webhooks/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/webhooks/disable_webhook.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.trigger_response import TriggerResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/triggers/{ref}/webhooks/disable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | TriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = TriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | TriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TriggerResponse]:
+    """ Disable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TriggerResponse | None:
+    """ Disable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TriggerResponse]:
+    """ Disable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TriggerResponse | None:
+    """ Disable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/webhooks/enable_webhook.py

@@ -0,0 +1,179 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.trigger_response import TriggerResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/triggers/{ref}/webhooks/enable".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | TriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = TriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | TriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TriggerResponse]:
+    """ Enable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TriggerResponse | None:
+    """ Enable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TriggerResponse]:
+    """ Enable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TriggerResponse | None:
+    """ Enable webhooks for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/webhooks/receive_webhook.py

@@ -0,0 +1,204 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.webhook_receiver_request import WebhookReceiverRequest
+from ...models.webhook_receiver_response import WebhookReceiverResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    webhook_key: str,
+    *,
+    body: WebhookReceiverRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/webhooks/{webhook_key}".format(webhook_key=quote(str(webhook_key), safe=""),),
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | WebhookReceiverResponse | None:
+    if response.status_code == 200:
+        response_200 = WebhookReceiverResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 429:
+        response_429 = cast(Any, None)
+        return response_429
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | WebhookReceiverResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    webhook_key: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: WebhookReceiverRequest,
+
+) -> Response[Any | WebhookReceiverResponse]:
+    """ Webhook receiver endpoint - receives webhook events and creates events
+
+    Args:
+        webhook_key (str):
+        body (WebhookReceiverRequest): Request body for webhook receiver endpoint
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | WebhookReceiverResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        webhook_key=webhook_key,
+body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    webhook_key: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: WebhookReceiverRequest,
+
+) -> Any | WebhookReceiverResponse | None:
+    """ Webhook receiver endpoint - receives webhook events and creates events
+
+    Args:
+        webhook_key (str):
+        body (WebhookReceiverRequest): Request body for webhook receiver endpoint
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | WebhookReceiverResponse
+     """
+
+
+    return sync_detailed(
+        webhook_key=webhook_key,
+client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    webhook_key: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: WebhookReceiverRequest,
+
+) -> Response[Any | WebhookReceiverResponse]:
+    """ Webhook receiver endpoint - receives webhook events and creates events
+
+    Args:
+        webhook_key (str):
+        body (WebhookReceiverRequest): Request body for webhook receiver endpoint
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | WebhookReceiverResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        webhook_key=webhook_key,
+body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    webhook_key: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: WebhookReceiverRequest,
+
+) -> Any | WebhookReceiverResponse | None:
+    """ Webhook receiver endpoint - receives webhook events and creates events
+
+    Args:
+        webhook_key (str):
+        body (WebhookReceiverRequest): Request body for webhook receiver endpoint
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | WebhookReceiverResponse
+     """
+
+
+    return (await asyncio_detailed(
+        webhook_key=webhook_key,
+client=client,
+body=body,
+
+    )).parsed

tests/generated_client/api/webhooks/regenerate_webhook_key.py

@@ -0,0 +1,183 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.trigger_response import TriggerResponse
+from typing import cast
+
+
+
+def _get_kwargs(
+    ref: str,
+
+) -> dict[str, Any]:
+    
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/triggers/{ref}/webhooks/regenerate".format(ref=quote(str(ref), safe=""),),
+    }
+
+
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | TriggerResponse | None:
+    if response.status_code == 200:
+        response_200 = TriggerResponse.from_dict(response.json())
+
+
+
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 500:
+        response_500 = cast(Any, None)
+        return response_500
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | TriggerResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TriggerResponse]:
+    """ Regenerate webhook key for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TriggerResponse | None:
+    """ Regenerate webhook key for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TriggerResponse
+     """
+
+
+    return sync_detailed(
+        ref=ref,
+client=client,
+
+    ).parsed
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Response[Any | TriggerResponse]:
+    """ Regenerate webhook key for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | TriggerResponse]
+     """
+
+
+    kwargs = _get_kwargs(
+        ref=ref,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+
+) -> Any | TriggerResponse | None:
+    """ Regenerate webhook key for a trigger
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | TriggerResponse
+     """
+
+
+    return (await asyncio_detailed(
+        ref=ref,
+client=client,
+
+    )).parsed

tests/generated_client/api/workflows/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """

tests/generated_client/api/workflows/create_workflow.py

@@ -0,0 +1,191 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+from ...models.create_workflow_request import CreateWorkflowRequest
+from ...models.create_workflow_response_201 import CreateWorkflowResponse201
+from typing import cast
+
+
+
+def _get_kwargs(
+    *,
+    body: CreateWorkflowRequest,
+
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+
+    
+
+    
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/api/v1/workflows",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | CreateWorkflowResponse201 | None:
+    if response.status_code == 201:
+        response_201 = CreateWorkflowResponse201.from_dict(response.json())
+
+
+
+        return response_201
+
+    if response.status_code == 400:
+        response_400 = cast(Any, None)
+        return response_400
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if response.status_code == 409:
+        response_409 = cast(Any, None)
+        return response_409
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any | CreateWorkflowResponse201]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateWorkflowRequest,
+
+) -> Response[Any | CreateWorkflowResponse201]:
+    """ Create a new workflow
+
+    Args:
+        body (CreateWorkflowRequest): Request DTO for creating a new workflow
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreateWorkflowResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: CreateWorkflowRequest,
+
+) -> Any | CreateWorkflowResponse201 | None:
+    """ Create a new workflow
+
+    Args:
+        body (CreateWorkflowRequest): Request DTO for creating a new workflow
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreateWorkflowResponse201
+     """
+
+
+    return sync_detailed(
+        client=client,
+body=body,
+
+    ).parsed
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: CreateWorkflowRequest,
+
+) -> Response[Any | CreateWorkflowResponse201]:
+    """ Create a new workflow
+
+    Args:
+        body (CreateWorkflowRequest): Request DTO for creating a new workflow
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | CreateWorkflowResponse201]
+     """
+
+
+    kwargs = _get_kwargs(
+        body=body,
+
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: CreateWorkflowRequest,
+
+) -> Any | CreateWorkflowResponse201 | None:
+    """ Create a new workflow
+
+    Args:
+        body (CreateWorkflowRequest): Request DTO for creating a new workflow
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | CreateWorkflowResponse201
+     """
+
+
+    return (await asyncio_detailed(
+        client=client,
+body=body,
+
+    )).parsed