agenta 0.8.4__py3-none-any.whl → 0.10.0__py3-none-any.whl

agenta/client/backend/client.py

@@ -17,27 +17,29 @@ from .types.add_variant_from_base_and_config_response import (
 )
 from .types.app import App
 from .types.app_variant_output import AppVariantOutput
+from .types.app_variant_output_extended import AppVariantOutputExtended
 from .types.base_output import BaseOutput
 from .types.container_templates_response import ContainerTemplatesResponse
 from .types.create_app_output import CreateAppOutput
-from .types.create_custom_evaluation import CreateCustomEvaluation
-from .types.custom_evaluation_detail import CustomEvaluationDetail
-from .types.custom_evaluation_names import CustomEvaluationNames
-from .types.custom_evaluation_output import CustomEvaluationOutput
+from .types.delete_evaluation import DeleteEvaluation
 from .types.docker_env_vars import DockerEnvVars
 from .types.environment_output import EnvironmentOutput
 from .types.evaluation import Evaluation
-from .types.evaluation_scenario import EvaluationScenario
-from .types.evaluation_scenario_input import EvaluationScenarioInput
-from .types.evaluation_scenario_output import EvaluationScenarioOutput
-from .types.evaluation_scenario_update_score import EvaluationScenarioUpdateScore
 from .types.evaluation_status_enum import EvaluationStatusEnum
 from .types.evaluation_type import EvaluationType
-from .types.evaluation_type_settings import EvaluationTypeSettings
 from .types.evaluation_webhook import EvaluationWebhook
+from .types.evaluator import Evaluator
+from .types.evaluator_config import EvaluatorConfig
 from .types.feedback import Feedback
 from .types.get_config_reponse import GetConfigReponse
 from .types.http_validation_error import HttpValidationError
+from .types.human_evaluation import HumanEvaluation
+from .types.human_evaluation_scenario import HumanEvaluationScenario
+from .types.human_evaluation_scenario_input import HumanEvaluationScenarioInput
+from .types.human_evaluation_scenario_output import HumanEvaluationScenarioOutput
+from .types.human_evaluation_scenario_update_score import (
+    HumanEvaluationScenarioUpdateScore,
+)
 from .types.image import Image
 from .types.invite_request import InviteRequest
 from .types.list_api_keys_output import ListApiKeysOutput
@@ -110,6 +112,12 @@ class AgentaApi:
 
         Returns:
         str: The created API key.
+
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_api_key()
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -145,7 +153,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.delete_api_key(key_prefix="key-prefix")
+        client.delete_api_key(key_prefix="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "DELETE",
@@ -173,6 +181,11 @@ class AgentaApi:
 
         Parameters:
             - key_prefix: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.validate_api_key(key_prefix="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -205,6 +218,11 @@ class AgentaApi:
 
         Parameters:
             - org_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_organization_details(org_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -242,6 +260,12 @@ class AgentaApi:
             - org_id: str.
 
             - request: InviteRequest.
+        ---
+        from agenta import InviteRequest
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.invite_to_org(org_id="string", request=InviteRequest(email="string"))
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -279,6 +303,12 @@ class AgentaApi:
             - org_id: str.
 
             - request: InviteRequest.
+        ---
+        from agenta import InviteRequest
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.resend_invitation(org_id="string", request=InviteRequest(email="string"))
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -316,6 +346,11 @@ class AgentaApi:
             - org_id: str.
 
             - token: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.add_user_to_org(org_id="string", token="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -341,6 +376,12 @@ class AgentaApi:
         """
         Parameters:
             - request: Organization.
+        ---
+        from agenta import Organization
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_organization(request=Organization(name="string", owner="string"))
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -375,6 +416,11 @@ class AgentaApi:
             - name: typing.Optional[str].
 
             - description: typing.Optional[str].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_organization(org_id="string")
         """
         _request: typing.Dict[str, typing.Any] = {}
         if name is not OMIT:
@@ -402,6 +448,12 @@ class AgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     def health_check(self) -> typing.Any:
+        """
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.health_check()
+        """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "health"),
@@ -417,6 +469,12 @@ class AgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     def user_profile(self) -> typing.Any:
+        """
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.user_profile()
+        """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "profile"),
@@ -448,7 +506,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.list_app_variants(app_id="app-id")
+        client.list_app_variants(app_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -468,47 +526,6 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def get_variant_by_env(self, *, app_id: str, environment: str) -> AppVariantOutput:
-        """
-        Retrieve the app variant based on the provided app_id and environment.
-
-        Args:
-        app_id (str): The ID of the app to retrieve the variant for.
-        environment (str): The environment of the app variant to retrieve.
-        stoken_session (SessionContainer, optional): The session token container. Defaults to Depends(verify_session()).
-
-        Raises:
-        HTTPException: If the app variant is not found (status_code=500), or if a ValueError is raised (status_code=400), or if any other exception is raised (status_code=500).
-
-        Returns:
-        AppVariantOutput: The retrieved app variant.
-
-        Parameters:
-            - app_id: str.
-
-            - environment: str.
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/", "apps/get_variant_by_env"
-            ),
-            params=remove_none_from_dict(
-                {"app_id": app_id, "environment": environment}
-            ),
-            headers=self._client_wrapper.get_headers(),
-            timeout=60,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(AppVariantOutput, _response.json())  # type: ignore
-        if _response.status_code == 422:
-            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
-        try:
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
     def list_apps(
         self,
         *,
@@ -576,6 +593,11 @@ class AgentaApi:
             - app_name: str.
 
             - organization_id: typing.Optional[str].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_app(app_name="string")
         """
         _request: typing.Dict[str, typing.Any] = {"app_name": app_name}
         if organization_id is not OMIT:
@@ -633,6 +655,11 @@ class AgentaApi:
             - base_name: typing.Optional[str].
 
             - config_name: typing.Optional[str].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.add_variant_from_image(app_id="string", variant_name="string", docker_id="string", tags="string")
         """
         _request: typing.Dict[str, typing.Any] = {
             "variant_name": variant_name,
@@ -672,6 +699,11 @@ class AgentaApi:
 
         Parameters:
             - app_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.remove_app(app_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "DELETE",
@@ -720,6 +752,11 @@ class AgentaApi:
             - env_vars: typing.Dict[str, str].
 
             - organization_id: typing.Optional[str].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_app_and_variant_from_template(app_name="string", template_id="string", env_vars={"string": "string"})
         """
         _request: typing.Dict[str, typing.Any] = {
             "app_name": app_name,
@@ -765,7 +802,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.list_environments(app_id="app-id")
+        client.list_environments(app_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -842,6 +879,34 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
+    def get_variant(self, variant_id: str) -> AppVariantOutputExtended:
+        """
+        Parameters:
+            - variant_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_variant(variant_id="string")
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", f"variants/{variant_id}"
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(AppVariantOutputExtended, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
     def start_variant(
         self,
         variant_id: str,
@@ -870,6 +935,16 @@ class AgentaApi:
             - action: VariantAction.
 
             - env_vars: typing.Optional[DockerEnvVars].
+        ---
+        from agenta import DockerEnvVars, VariantAction, VariantActionEnum
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.start_variant(
+            variant_id="string",
+            action=VariantAction(action=VariantActionEnum.START),
+            env_vars=DockerEnvVars(env_vars={"string": "string"}),
+        )
         """
         _request: typing.Dict[str, typing.Any] = {"action": action}
         if env_vars is not OMIT:
@@ -906,6 +981,11 @@ class AgentaApi:
 
         Parameters:
             - variant_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.remove_variant(variant_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "DELETE",
@@ -946,6 +1026,11 @@ class AgentaApi:
             - variant_id: str.
 
             - parameters: typing.Dict[str, typing.Any].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_variant_parameters(variant_id="string", parameters={"string": {"unknown": "string", "type": "unknown"}})
         """
         _response = self._client_wrapper.httpx_client.request(
             "PUT",
@@ -985,6 +1070,12 @@ class AgentaApi:
             - variant_id: str.
 
             - request: Image.
+        ---
+        from agenta import Image
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_variant_image(variant_id="string", request=Image(docker_id="string", tags="string"))
         """
         _response = self._client_wrapper.httpx_client.request(
             "PUT",
@@ -1006,7 +1097,9 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def fetch_list_evaluations(self, *, app_id: str) -> typing.List[Evaluation]:
+    def fetch_list_evaluations_evaluations_get(
+        self, *, app_id: str
+    ) -> typing.List[Evaluation]:
         """
         Fetches a list of evaluations, optionally filtered by an app ID.
 
@@ -1022,7 +1115,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.fetch_list_evaluations(app_id="app-id")
+        client.fetch_list_evaluations_evaluations_get(app_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -1049,7 +1142,6 @@ class AgentaApi:
         app_id: str,
         variant_ids: typing.List[str],
         evaluation_type: EvaluationType,
-        evaluation_type_settings: typing.Optional[EvaluationTypeSettings] = OMIT,
         inputs: typing.List[str],
         testset_id: str,
         status: str,
@@ -1068,30 +1160,40 @@ class AgentaApi:
 
             - evaluation_type: EvaluationType.
 
-            - evaluation_type_settings: typing.Optional[EvaluationTypeSettings].
-
             - inputs: typing.List[str].
 
             - testset_id: str.
 
             - status: str.
+        ---
+        from agenta import EvaluationType
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_evaluation(
+            app_id="string",
+            variant_ids=[],
+            evaluation_type=EvaluationType.HUMAN_A_B_TESTING,
+            inputs=[],
+            testset_id="string",
+            status="string",
+        )
         """
-        _request: typing.Dict[str, typing.Any] = {
-            "app_id": app_id,
-            "variant_ids": variant_ids,
-            "evaluation_type": evaluation_type,
-            "inputs": inputs,
-            "testset_id": testset_id,
-            "status": status,
-        }
-        if evaluation_type_settings is not OMIT:
-            _request["evaluation_type_settings"] = evaluation_type_settings
         _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/", "evaluations"
+                f"{self._client_wrapper.get_base_url()}/", "human-evaluations"
+            ),
+            json=jsonable_encoder(
+                {
+                    "app_id": app_id,
+                    "variant_ids": variant_ids,
+                    "evaluation_type": evaluation_type,
+                    "inputs": inputs,
+                    "testset_id": testset_id,
+                    "status": status,
+                }
             ),
-            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1105,9 +1207,7 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def delete_evaluations(
-        self, *, evaluations_ids: typing.List[str]
-    ) -> typing.List[str]:
+    def delete_evaluations(self, *, request: DeleteEvaluation) -> typing.List[str]:
         """
         Delete specific comparison tables based on their unique IDs.
 
@@ -1118,19 +1218,20 @@ class AgentaApi:
         A list of the deleted comparison tables' IDs.
 
         Parameters:
-            - evaluations_ids: typing.List[str].
+            - request: DeleteEvaluation.
         ---
+        from agenta import DeleteEvaluation
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.delete_evaluations(evaluations_ids=[])
+        client.delete_evaluations(request=DeleteEvaluation(evaluations_ids=[]))
         """
         _response = self._client_wrapper.httpx_client.request(
             "DELETE",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/", "evaluations"
             ),
-            json=jsonable_encoder({"evaluations_ids": evaluations_ids}),
+            json=jsonable_encoder(request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1144,30 +1245,36 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def fetch_evaluation(self, evaluation_id: str) -> Evaluation:
+    def fetch_evaluation_status(self, evaluation_id: str) -> typing.Any:
         """
-        Fetches a single evaluation based on its ID.
+        Fetches the status of the evaluation.
 
         Args:
-        evaluation_id (str): The ID of the evaluation to fetch.
+        evaluation_id (str): the evaluation id
+        request (Request): the request object
 
         Returns:
-        Evaluation: The fetched evaluation.
+        (str): the evaluation status
 
         Parameters:
             - evaluation_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_evaluation_status(evaluation_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}",
+                f"evaluations/{evaluation_id}/status",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(Evaluation, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1176,41 +1283,31 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def update_evaluation(
-        self,
-        evaluation_id: str,
-        *,
-        status: typing.Optional[EvaluationStatusEnum] = OMIT,
-        evaluation_type_settings: typing.Optional[EvaluationTypeSettings] = OMIT,
-    ) -> typing.Any:
+    def fetch_evaluation_results(self, evaluation_id: str) -> typing.Any:
         """
-        Updates an evaluation's status.
+        Fetches the results of the evaluation
 
-        Raises:
-        HTTPException: If the columns in the test set do not match with the inputs in the variant.
+        Args:
+        evaluation_id (str): the evaluation id
+        request (Request): the request object
 
         Returns:
-        None: A 204 No Content status code, indicating that the update was successful.
+        _type_: _description_
 
         Parameters:
             - evaluation_id: str.
+        ---
+        from agenta.client import AgentaApi
 
-            - status: typing.Optional[EvaluationStatusEnum].
-
-            - evaluation_type_settings: typing.Optional[EvaluationTypeSettings].
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_evaluation_results(evaluation_id="string")
         """
-        _request: typing.Dict[str, typing.Any] = {}
-        if status is not OMIT:
-            _request["status"] = status
-        if evaluation_type_settings is not OMIT:
-            _request["evaluation_type_settings"] = evaluation_type_settings
         _response = self._client_wrapper.httpx_client.request(
-            "PUT",
+            "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}",
+                f"evaluations/{evaluation_id}/results",
             ),
-            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1226,7 +1323,7 @@ class AgentaApi:
 
     def fetch_evaluation_scenarios(
         self, evaluation_id: str
-    ) -> typing.List[EvaluationScenario]:
+    ) -> typing.List[HumanEvaluationScenario]:
         """
         Fetches evaluation scenarios for a given evaluation ID.
 
@@ -1245,19 +1342,19 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.fetch_evaluation_scenarios(evaluation_id="evaluation-id")
+        client.fetch_evaluation_scenarios(evaluation_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/evaluation_scenarios",
+                f"human-evaluations/{evaluation_id}/evaluation_scenarios",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.List[EvaluationScenario], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.List[HumanEvaluationScenario], _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1266,35 +1363,35 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def create_evaluation_scenario(
-        self, evaluation_id: str, *, request: EvaluationScenario
-    ) -> typing.Any:
+    def fetch_evaluation(self, evaluation_id: str) -> Evaluation:
         """
-        Create a new evaluation scenario for a given evaluation ID.
+        Fetches a single evaluation based on its ID.
 
-        Raises:
-        HTTPException: If evaluation not found or access denied.
+        Args:
+        evaluation_id (str): The ID of the evaluation to fetch.
 
         Returns:
-        None: 204 No Content status code upon success.
+        Evaluation: The fetched evaluation.
 
         Parameters:
             - evaluation_id: str.
+        ---
+        from agenta.client import AgentaApi
 
-            - request: EvaluationScenario.
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_evaluation(evaluation_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
-            "POST",
+            "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/evaluation_scenario",
+                f"evaluations/{evaluation_id}",
             ),
-            json=jsonable_encoder(request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(Evaluation, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1303,72 +1400,66 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def update_evaluation_scenario(
-        self,
-        evaluation_id: str,
-        evaluation_scenario_id: str,
-        evaluation_type: EvaluationType,
-        *,
-        vote: typing.Optional[str] = OMIT,
-        score: typing.Optional[EvaluationScenarioUpdateScore] = OMIT,
-        correct_answer: typing.Optional[str] = OMIT,
-        outputs: typing.Optional[typing.List[EvaluationScenarioOutput]] = OMIT,
-        inputs: typing.Optional[typing.List[EvaluationScenarioInput]] = OMIT,
-        is_pinned: typing.Optional[bool] = OMIT,
-        note: typing.Optional[str] = OMIT,
-    ) -> typing.Any:
+    def webhook_example_fake(self) -> EvaluationWebhook:
         """
-        Updates an evaluation scenario's vote or score based on its type.
-
-        Raises:
-        HTTPException: If update fails or unauthorized.
+        Returns a fake score response for example webhook evaluation
 
         Returns:
-        None: 204 No Content status code upon successful update.
-
-        Parameters:
-            - evaluation_id: str.
+        _description_
 
-            - evaluation_scenario_id: str.
+        ---
+        from agenta.client import AgentaApi
 
-            - evaluation_type: EvaluationType.
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.webhook_example_fake()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                "evaluations/webhook_example_fake",
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(EvaluationWebhook, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
 
-            - vote: typing.Optional[str].
+    def fetch_evaluation_scenarios_evaluations_evaluation_scenarios_comparison_results_get(
+        self, *, evaluations_ids: str
+    ) -> typing.Any:
+        """
+        Fetches evaluation scenarios for a given evaluation ID.
 
-            - score: typing.Optional[EvaluationScenarioUpdateScore].
+        Arguments:
+        evaluation_id (str): The ID of the evaluation for which to fetch scenarios.
 
-            - correct_answer: typing.Optional[str].
+        Raises:
+        HTTPException: If the evaluation is not found or access is denied.
 
-            - outputs: typing.Optional[typing.List[EvaluationScenarioOutput]].
+        Returns:
+        List[EvaluationScenario]: A list of evaluation scenarios.
 
-            - inputs: typing.Optional[typing.List[EvaluationScenarioInput]].
-
-            - is_pinned: typing.Optional[bool].
+        Parameters:
+            - evaluations_ids: str.
+        ---
+        from agenta.client import AgentaApi
 
-            - note: typing.Optional[str].
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_evaluation_scenarios_evaluations_evaluation_scenarios_comparison_results_get(evaluations_ids="string")
         """
-        _request: typing.Dict[str, typing.Any] = {}
-        if vote is not OMIT:
-            _request["vote"] = vote
-        if score is not OMIT:
-            _request["score"] = score
-        if correct_answer is not OMIT:
-            _request["correct_answer"] = correct_answer
-        if outputs is not OMIT:
-            _request["outputs"] = outputs
-        if inputs is not OMIT:
-            _request["inputs"] = inputs
-        if is_pinned is not OMIT:
-            _request["is_pinned"] = is_pinned
-        if note is not OMIT:
-            _request["note"] = note
         _response = self._client_wrapper.httpx_client.request(
-            "PUT",
+            "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/evaluation_scenario/{evaluation_scenario_id}/{evaluation_type}",
+                "evaluations/evaluation_scenarios/comparison-results",
             ),
-            json=jsonable_encoder(_request),
+            params=remove_none_from_dict({"evaluations_ids": evaluations_ids}),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1382,65 +1473,37 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def evaluate_ai_critique(
-        self,
-        *,
-        correct_answer: str,
-        llm_app_prompt_template: typing.Optional[str] = OMIT,
-        inputs: typing.List[EvaluationScenarioInput],
-        outputs: typing.List[EvaluationScenarioOutput],
-        evaluation_prompt_template: typing.Optional[str] = OMIT,
-        open_ai_key: typing.Optional[str] = OMIT,
-    ) -> str:
+    def fetch_list_human_evaluations_human_evaluations_get(
+        self, *, app_id: str
+    ) -> typing.List[HumanEvaluation]:
         """
-        Evaluate AI critique based on the given payload.
+        Fetches a list of evaluations, optionally filtered by an app ID.
 
         Args:
-        payload (AICritiqueCreate): The payload containing data for AI critique evaluation.
-        stoken_session (SessionContainer): The session container verified by `verify_session`.
+        app_id (Optional[str]): An optional app ID to filter the evaluations.
 
         Returns:
-        str: The output of the AI critique evaluation.
-
-        Raises:
-        HTTPException: If any exception occurs during the evaluation.
+        List[HumanEvaluation]: A list of evaluations.
 
         Parameters:
-            - correct_answer: str.
-
-            - llm_app_prompt_template: typing.Optional[str].
-
-            - inputs: typing.List[EvaluationScenarioInput].
-
-            - outputs: typing.List[EvaluationScenarioOutput].
-
-            - evaluation_prompt_template: typing.Optional[str].
+            - app_id: str.
+        ---
+        from agenta.client import AgentaApi
 
-            - open_ai_key: typing.Optional[str].
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_list_human_evaluations_human_evaluations_get(app_id="string")
         """
-        _request: typing.Dict[str, typing.Any] = {
-            "correct_answer": correct_answer,
-            "inputs": inputs,
-            "outputs": outputs,
-        }
-        if llm_app_prompt_template is not OMIT:
-            _request["llm_app_prompt_template"] = llm_app_prompt_template
-        if evaluation_prompt_template is not OMIT:
-            _request["evaluation_prompt_template"] = evaluation_prompt_template
-        if open_ai_key is not OMIT:
-            _request["open_ai_key"] = open_ai_key
         _response = self._client_wrapper.httpx_client.request(
-            "POST",
+            "GET",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                "evaluations/evaluation_scenario/ai_critique",
+                f"{self._client_wrapper.get_base_url()}/", "human-evaluations"
             ),
-            json=jsonable_encoder(_request),
+            params=remove_none_from_dict({"app_id": app_id}),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(str, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.List[HumanEvaluation], _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1449,38 +1512,38 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def get_evaluation_scenario_score(
-        self, evaluation_scenario_id: str
-    ) -> typing.Dict[str, str]:
+    def delete_evaluations_human_evaluations_delete(
+        self, *, request: DeleteEvaluation
+    ) -> typing.List[str]:
         """
-        Fetch the score of a specific evaluation scenario.
+        Delete specific comparison tables based on their unique IDs.
 
         Args:
-        evaluation_scenario_id: The ID of the evaluation scenario to fetch.
-        stoken_session: Session data, verified by `verify_session`.
+        delete_evaluations (List[str]): The unique identifiers of the comparison tables to delete.
 
         Returns:
-        Dictionary containing the scenario ID and its score.
+        A list of the deleted comparison tables' IDs.
 
         Parameters:
-            - evaluation_scenario_id: str.
+            - request: DeleteEvaluation.
         ---
+        from agenta import DeleteEvaluation
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.get_evaluation_scenario_score(evaluation_scenario_id="evaluation-scenario-id")
+        client.delete_evaluations_human_evaluations_delete(request=DeleteEvaluation(evaluations_ids=[]))
         """
         _response = self._client_wrapper.httpx_client.request(
-            "GET",
+            "DELETE",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
+                f"{self._client_wrapper.get_base_url()}/", "human-evaluations"
             ),
+            json=jsonable_encoder(request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Dict[str, str], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.List[str], _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1489,35 +1552,37 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def update_evaluation_scenario_score(
-        self, evaluation_scenario_id: str, *, score: float
-    ) -> typing.Any:
+    def fetch_human_evaluation_human_evaluations_evaluation_id_get(
+        self, evaluation_id: str
+    ) -> HumanEvaluation:
         """
-        Updates the score of an evaluation scenario.
+        Fetches a single evaluation based on its ID.
 
-        Raises:
-        HTTPException: Server error if the evaluation update fails.
+        Args:
+        evaluation_id (str): The ID of the evaluation to fetch.
 
         Returns:
-        None: 204 No Content status code upon successful update.
+        HumanEvaluation: The fetched evaluation.
 
         Parameters:
-            - evaluation_scenario_id: str.
+            - evaluation_id: str.
+        ---
+        from agenta.client import AgentaApi
 
-            - score: float.
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.fetch_human_evaluation_human_evaluations_evaluation_id_get(evaluation_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
-            "PUT",
+            "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
+                f"human-evaluations/{evaluation_id}",
             ),
-            json=jsonable_encoder({"score": score}),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(HumanEvaluation, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1526,25 +1591,42 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def fetch_results(self, evaluation_id: str) -> typing.Any:
+    def update_human_evaluation(
+        self,
+        evaluation_id: str,
+        *,
+        status: typing.Optional[EvaluationStatusEnum] = OMIT,
+    ) -> typing.Any:
         """
-        Fetch all the results for one the comparison table
+        Updates an evaluation's status.
 
-        Arguments:
-        evaluation*id -- \_description*
+        Raises:
+        HTTPException: If the columns in the test set do not match with the inputs in the variant.
 
         Returns:
-        _description_
+        None: A 204 No Content status code, indicating that the update was successful.
 
         Parameters:
             - evaluation_id: str.
+
+            - status: typing.Optional[EvaluationStatusEnum].
+        ---
+        from agenta import EvaluationStatusEnum
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_human_evaluation(evaluation_id="string", status=EvaluationStatusEnum.EVALUATION_INITIALIZED)
         """
+        _request: typing.Dict[str, typing.Any] = {}
+        if status is not OMIT:
+            _request["status"] = status
         _response = self._client_wrapper.httpx_client.request(
-            "GET",
+            "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/results",
+                f"human-evaluations/{evaluation_id}",
             ),
+            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1558,26 +1640,84 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def create_custom_evaluation(
-        self, *, request: CreateCustomEvaluation
+    def update_evaluation_scenario_router_human_evaluations_evaluation_id_evaluation_scenario_evaluation_scenario_id_evaluation_type_put(
+        self,
+        evaluation_id: str,
+        evaluation_scenario_id: str,
+        evaluation_type: EvaluationType,
+        *,
+        vote: typing.Optional[str] = OMIT,
+        score: typing.Optional[HumanEvaluationScenarioUpdateScore] = OMIT,
+        correct_answer: typing.Optional[str] = OMIT,
+        outputs: typing.Optional[typing.List[HumanEvaluationScenarioOutput]] = OMIT,
+        inputs: typing.Optional[typing.List[HumanEvaluationScenarioInput]] = OMIT,
+        is_pinned: typing.Optional[bool] = OMIT,
+        note: typing.Optional[str] = OMIT,
     ) -> typing.Any:
         """
-        Create evaluation with custom python code.
+        Updates an evaluation scenario's vote or score based on its type.
 
-        Args:
+        Raises:
+        HTTPException: If update fails or unauthorized.
 
-        custom_evaluation_payload (CreateCustomEvaluation): the required payload
+        Returns:
+        None: 204 No Content status code upon successful update.
 
         Parameters:
-            - request: CreateCustomEvaluation.
+            - evaluation_id: str.
+
+            - evaluation_scenario_id: str.
+
+            - evaluation_type: EvaluationType.
+
+            - vote: typing.Optional[str].
+
+            - score: typing.Optional[HumanEvaluationScenarioUpdateScore].
+
+            - correct_answer: typing.Optional[str].
+
+            - outputs: typing.Optional[typing.List[HumanEvaluationScenarioOutput]].
+
+            - inputs: typing.Optional[typing.List[HumanEvaluationScenarioInput]].
+
+            - is_pinned: typing.Optional[bool].
+
+            - note: typing.Optional[str].
+        ---
+        from agenta import EvaluationType, HumanEvaluationScenarioInput, HumanEvaluationScenarioOutput
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_evaluation_scenario_router_human_evaluations_evaluation_id_evaluation_scenario_evaluation_scenario_id_evaluation_type_put(
+            evaluation_id="string",
+            evaluation_scenario_id="string",
+            evaluation_type=EvaluationType.HUMAN_A_B_TESTING,
+            outputs=[HumanEvaluationScenarioOutput(variant_id="string", variant_output="string")],
+            inputs=[HumanEvaluationScenarioInput(input_name="string", input_value="string")],
+        )
         """
+        _request: typing.Dict[str, typing.Any] = {}
+        if vote is not OMIT:
+            _request["vote"] = vote
+        if score is not OMIT:
+            _request["score"] = score
+        if correct_answer is not OMIT:
+            _request["correct_answer"] = correct_answer
+        if outputs is not OMIT:
+            _request["outputs"] = outputs
+        if inputs is not OMIT:
+            _request["inputs"] = inputs
+        if is_pinned is not OMIT:
+            _request["is_pinned"] = is_pinned
+        if note is not OMIT:
+            _request["note"] = note
         _response = self._client_wrapper.httpx_client.request(
-            "POST",
+            "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                "evaluations/custom_evaluation",
+                f"human-evaluations/{evaluation_id}/evaluation_scenario/{evaluation_scenario_id}/{evaluation_type}",
             ),
-            json=jsonable_encoder(request),
+            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1591,30 +1731,40 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def get_custom_evaluation(self, id: str) -> CustomEvaluationDetail:
+    def get_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_get(
+        self, evaluation_scenario_id: str
+    ) -> typing.Dict[str, str]:
         """
-        Get the custom code evaluation detail.
+        Fetch the score of a specific evaluation scenario.
 
         Args:
-        id (str): the id of the custom evaluation
+        evaluation_scenario_id: The ID of the evaluation scenario to fetch.
+        stoken_session: Session data, verified by `verify_session`.
 
         Returns:
-        CustomEvaluationDetail: Detail of the custom evaluation
+        Dictionary containing the scenario ID and its score.
 
         Parameters:
-            - id: str.
+            - evaluation_scenario_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_get(
+            evaluation_scenario_id="string"
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/{id}",
+                f"human-evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(CustomEvaluationDetail, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Dict[str, str], _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1623,28 +1773,37 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def update_custom_evaluation(
-        self, id: str, *, request: CreateCustomEvaluation
+    def update_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_put(
+        self, evaluation_scenario_id: str, *, score: float
     ) -> typing.Any:
         """
-        Update a custom code evaluation.
-        Args:
-        id (str): the ID of the custom evaluation to update
-        updated_data (CreateCustomEvaluation): the payload with updated data
-        stoken_session (SessionContainer): session container for authentication
+        Updates the score of an evaluation scenario.
+
+        Raises:
+        HTTPException: Server error if the evaluation update fails.
+
+        Returns:
+        None: 204 No Content status code upon successful update.
 
         Parameters:
-            - id: str.
+            - evaluation_scenario_id: str.
+
+            - score: float.
+        ---
+        from agenta.client import AgentaApi
 
-            - request: CreateCustomEvaluation.
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_put(
+            evaluation_scenario_id="string", score=1.1
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
             "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/{id}",
+                f"human-evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
             ),
-            json=jsonable_encoder(request),
+            json=jsonable_encoder({"score": score}),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -1658,37 +1817,35 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def list_custom_evaluations(
-        self, app_id: str
-    ) -> typing.List[CustomEvaluationOutput]:
+    def fetch_results(self, evaluation_id: str) -> typing.Any:
         """
-        List the custom code evaluations for a given app.
+        Fetch all the results for one the comparison table
 
-        Args:
-        app_id (str): the id of the app
+        Arguments:
+        evaluation*id -- \_description*
 
         Returns:
-        List[CustomEvaluationOutput]: a list of custom evaluation
+        _description_
 
         Parameters:
-            - app_id: str.
+            - evaluation_id: str.
         ---
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.list_custom_evaluations(app_id="app-id")
+        client.fetch_results(evaluation_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/list/{app_id}",
+                f"human-evaluations/{evaluation_id}/results",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.List[CustomEvaluationOutput], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1697,37 +1854,66 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def get_custom_evaluation_names(
-        self, app_name: str
-    ) -> typing.List[CustomEvaluationNames]:
+    def get_evaluators_endpoint_evaluators_get(self) -> typing.List[Evaluator]:
+        """
+        Endpoint to fetch a list of evaluators.
+
+        Returns:
+        List[Evaluator]: A list of evaluator objects.
+
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_evaluators_endpoint_evaluators_get()
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", "evaluators"
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[Evaluator], _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def get_evaluator_configs_evaluators_configs_get(
+        self, *, app_id: str
+    ) -> typing.List[EvaluatorConfig]:
         """
-        Get the names of custom evaluation for a given app.
+        Endpoint to fetch evaluator configurations for a specific app.
 
         Args:
-        app_name (str): the name of the app the evaluation belongs to
+        app_id (str): The ID of the app.
 
         Returns:
-        List[CustomEvaluationNames]: the list of name of custom evaluations
+        List[EvaluatorConfigDB]: A list of evaluator configuration objects.
 
         Parameters:
-            - app_name: str.
+            - app_id: str.
         ---
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.get_custom_evaluation_names(app_name="app-name")
+        client.get_evaluator_configs_evaluators_configs_get(app_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/{app_name}/names",
+                f"{self._client_wrapper.get_base_url()}/", "evaluators/configs"
             ),
+            params=remove_none_from_dict({"app_id": app_id}),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.List[CustomEvaluationNames], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.List[EvaluatorConfig], _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1736,59 +1922,60 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def execute_custom_evaluation(
+    def create_new_evaluator_config_evaluators_configs_post(
         self,
-        evaluation_id: str,
         *,
-        inputs: typing.List[typing.Dict[str, typing.Any]],
         app_id: str,
-        variant_id: str,
-        correct_answer: str,
-        outputs: typing.List[typing.Dict[str, typing.Any]],
-    ) -> typing.Any:
+        name: str,
+        evaluator_key: str,
+        settings_values: typing.Dict[str, typing.Any],
+    ) -> EvaluatorConfig:
         """
-        Execute a custom evaluation code.
+        Endpoint to fetch evaluator configurations for a specific app.
 
         Args:
-        evaluation_id (str): the custom evaluation id
-        payload (ExecuteCustomEvaluationCode): the required payload
+        app_id (str): The ID of the app.
 
         Returns:
-        float: the result of the evaluation custom code
+        EvaluatorConfigDB: Evaluator configuration api model.
 
         Parameters:
-            - evaluation_id: str.
-
-            - inputs: typing.List[typing.Dict[str, typing.Any]].
-
             - app_id: str.
 
-            - variant_id: str.
+            - name: str.
+
+            - evaluator_key: str.
 
-            - correct_answer: str.
+            - settings_values: typing.Dict[str, typing.Any].
+        ---
+        from agenta.client import AgentaApi
 
-            - outputs: typing.List[typing.Dict[str, typing.Any]].
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_new_evaluator_config_evaluators_configs_post(
+            app_id="string",
+            name="string",
+            evaluator_key="string",
+            settings_values={"string": {"unknown": "string", "type": "unknown"}},
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/execute/{evaluation_id}",
+                f"{self._client_wrapper.get_base_url()}/", "evaluators/configs"
             ),
             json=jsonable_encoder(
                 {
-                    "inputs": inputs,
                     "app_id": app_id,
-                    "variant_id": variant_id,
-                    "correct_answer": correct_answer,
-                    "outputs": outputs,
+                    "name": name,
+                    "evaluator_key": evaluator_key,
+                    "settings_values": settings_values,
                 }
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(EvaluatorConfig, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -1797,24 +1984,130 @@ class AgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    def webhook_example_fake(self) -> EvaluationWebhook:
+    def get_evaluator_config_evaluators_configs_evaluator_config_id_get(
+        self, evaluator_config_id: str
+    ) -> EvaluatorConfig:
         """
-        Returns a fake score response for example webhook evaluation
+        Endpoint to fetch evaluator configurations for a specific app.
 
         Returns:
-        _description_
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(
+        List[EvaluatorConfigDB]: A list of evaluator configuration objects.
+
+        Parameters:
+            - evaluator_config_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_evaluator_config_evaluators_configs_evaluator_config_id_get(evaluator_config_id="string")
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                "evaluations/webhook_example_fake",
+                f"evaluators/configs/{evaluator_config_id}",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(EvaluationWebhook, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(EvaluatorConfig, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def update_evaluator_config_evaluators_configs_evaluator_config_id_put(
+        self,
+        evaluator_config_id: str,
+        *,
+        name: typing.Optional[str] = OMIT,
+        evaluator_key: typing.Optional[str] = OMIT,
+        settings_values: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
+    ) -> EvaluatorConfig:
+        """
+        Endpoint to update evaluator configurations for a specific app.
+
+        Returns:
+        List[EvaluatorConfigDB]: A list of evaluator configuration objects.
+
+        Parameters:
+            - evaluator_config_id: str.
+
+            - name: typing.Optional[str].
+
+            - evaluator_key: typing.Optional[str].
+
+            - settings_values: typing.Optional[typing.Dict[str, typing.Any]].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_evaluator_config_evaluators_configs_evaluator_config_id_put(evaluator_config_id="string")
+        """
+        _request: typing.Dict[str, typing.Any] = {}
+        if name is not OMIT:
+            _request["name"] = name
+        if evaluator_key is not OMIT:
+            _request["evaluator_key"] = evaluator_key
+        if settings_values is not OMIT:
+            _request["settings_values"] = settings_values
+        _response = self._client_wrapper.httpx_client.request(
+            "PUT",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                f"evaluators/configs/{evaluator_config_id}",
+            ),
+            json=jsonable_encoder(_request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(EvaluatorConfig, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    def delete_evaluator_config_evaluators_configs_evaluator_config_id_delete(
+        self, evaluator_config_id: str
+    ) -> bool:
+        """
+        Endpoint to delete a specific evaluator configuration.
+
+        Args:
+        evaluator_config_id (str): The unique identifier of the evaluator configuration.
+
+        Returns:
+        bool: True if deletion was successful, False otherwise.
+
+        Parameters:
+            - evaluator_config_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.delete_evaluator_config_evaluators_configs_evaluator_config_id_delete(evaluator_config_id="string")
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "DELETE",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                f"evaluators/configs/{evaluator_config_id}",
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(bool, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -1880,6 +2173,12 @@ class AgentaApi:
 
         Returns:
         dict: The result of the import process.
+
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.import_testset()
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -1917,6 +2216,12 @@ class AgentaApi:
             - app_id: str.
 
             - request: NewTestset.
+        ---
+        from agenta import NewTestset
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_testset(app_id="string", request=NewTestset(name="string", csvdata=[]))
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -1949,6 +2254,11 @@ class AgentaApi:
 
         Parameters:
             - testset_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_single_testset(testset_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -1983,6 +2293,12 @@ class AgentaApi:
             - testset_id: str.
 
             - request: NewTestset.
+        ---
+        from agenta import NewTestset
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_testset(testset_id="string", request=NewTestset(name="string", csvdata=[]))
         """
         _response = self._client_wrapper.httpx_client.request(
             "PUT",
@@ -2021,7 +2337,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.get_testsets(app_id="app-id")
+        client.get_testsets(app_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2125,6 +2441,11 @@ class AgentaApi:
 
         Parameters:
             - variant_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.restart_container(variant_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -2197,6 +2518,11 @@ class AgentaApi:
             - base_id: typing.Optional[str].
 
             - variant_id: typing.Optional[str].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.construct_app_container_url()
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2237,6 +2563,11 @@ class AgentaApi:
             - environment_name: str.
 
             - variant_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.deploy_to_environment(environment_name="string", variant_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -2294,6 +2625,19 @@ class AgentaApi:
             - end_time: dt.datetime.
 
             - spans: typing.List[str].
+        ---
+        import datetime
+
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_trace(
+            latency=1.1,
+            status="string",
+            start_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+            end_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+            spans=[],
+        )
         """
         _request: typing.Dict[str, typing.Any] = {
             "latency": latency,
@@ -2341,7 +2685,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.get_traces(app_id="app-id", variant_id="variant-id")
+        client.get_traces(app_id="string", variant_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2366,6 +2710,11 @@ class AgentaApi:
         """
         Parameters:
             - trace_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_single_trace(trace_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2392,6 +2741,11 @@ class AgentaApi:
             - trace_id: str.
 
             - status: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_trace_status(trace_id="string", status="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "PUT",
@@ -2466,6 +2820,18 @@ class AgentaApi:
             - cost: typing.Optional[float].
 
             - tags: typing.Optional[typing.List[str]].
+        ---
+        import datetime
+
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_span(
+            event_name="string",
+            start_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+            status="string",
+            end_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+        )
         """
         _request: typing.Dict[str, typing.Any] = {
             "event_name": event_name,
@@ -2524,7 +2890,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.get_spans_of_trace(trace_id="trace-id")
+        client.get_spans_of_trace(trace_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2553,7 +2919,7 @@ class AgentaApi:
         from agenta.client import AgentaApi
 
         client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        client.get_feedbacks(trace_id="trace-id")
+        client.get_feedbacks(trace_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2591,6 +2957,11 @@ class AgentaApi:
             - score: typing.Optional[float].
 
             - meta: typing.Optional[typing.Dict[str, typing.Any]].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.create_feedback(trace_id="string")
         """
         _request: typing.Dict[str, typing.Any] = {}
         if feedback is not OMIT:
@@ -2625,6 +2996,11 @@ class AgentaApi:
             - trace_id: str.
 
             - feedback_id: str.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_feedback(trace_id="string", feedback_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2665,6 +3041,11 @@ class AgentaApi:
             - score: typing.Optional[float].
 
             - meta: typing.Optional[typing.Dict[str, typing.Any]].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.update_feedback(trace_id="string", feedback_id="string", feedback="string")
         """
         _request: typing.Dict[str, typing.Any] = {"feedback": feedback}
         if score is not OMIT:
@@ -2727,6 +3108,12 @@ class AgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     def get_own_org(self) -> OrganizationOutput:
+        """
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_own_org()
+        """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
@@ -2804,6 +3191,11 @@ class AgentaApi:
             - config_name: typing.Optional[str].
 
             - environment_name: typing.Optional[str].
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.get_config(base_id="string")
         """
         _response = self._client_wrapper.httpx_client.request(
             "GET",
@@ -2845,6 +3237,16 @@ class AgentaApi:
             - parameters: typing.Dict[str, typing.Any].
 
             - overwrite: bool.
+        ---
+        from agenta.client import AgentaApi
+
+        client = AgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        client.save_config(
+            base_id="string",
+            config_name="string",
+            parameters={"string": {"unknown": "string", "type": "unknown"}},
+            overwrite=True,
+        )
         """
         _response = self._client_wrapper.httpx_client.request(
             "POST",
@@ -2920,6 +3322,12 @@ class AsyncAgentaApi:
 
         Returns:
         str: The created API key.
+
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_api_key()
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -2955,7 +3363,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.delete_api_key(key_prefix="key-prefix")
+        await client.delete_api_key(key_prefix="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "DELETE",
@@ -2983,6 +3391,11 @@ class AsyncAgentaApi:
 
         Parameters:
             - key_prefix: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.validate_api_key(key_prefix="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -3015,6 +3428,11 @@ class AsyncAgentaApi:
 
         Parameters:
             - org_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_organization_details(org_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -3052,6 +3470,12 @@ class AsyncAgentaApi:
             - org_id: str.
 
             - request: InviteRequest.
+        ---
+        from agenta import InviteRequest
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.invite_to_org(org_id="string", request=InviteRequest(email="string"))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -3091,6 +3515,12 @@ class AsyncAgentaApi:
             - org_id: str.
 
             - request: InviteRequest.
+        ---
+        from agenta import InviteRequest
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.resend_invitation(org_id="string", request=InviteRequest(email="string"))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -3128,6 +3558,11 @@ class AsyncAgentaApi:
             - org_id: str.
 
             - token: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.add_user_to_org(org_id="string", token="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -3153,6 +3588,12 @@ class AsyncAgentaApi:
         """
         Parameters:
             - request: Organization.
+        ---
+        from agenta import Organization
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_organization(request=Organization(name="string", owner="string"))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -3187,6 +3628,11 @@ class AsyncAgentaApi:
             - name: typing.Optional[str].
 
             - description: typing.Optional[str].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_organization(org_id="string")
         """
         _request: typing.Dict[str, typing.Any] = {}
         if name is not OMIT:
@@ -3214,6 +3660,12 @@ class AsyncAgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     async def health_check(self) -> typing.Any:
+        """
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.health_check()
+        """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "health"),
@@ -3229,6 +3681,12 @@ class AsyncAgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     async def user_profile(self) -> typing.Any:
+        """
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.user_profile()
+        """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(f"{self._client_wrapper.get_base_url()}/", "profile"),
@@ -3260,7 +3718,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.list_app_variants(app_id="app-id")
+        await client.list_app_variants(app_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -3280,49 +3738,6 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def get_variant_by_env(
-        self, *, app_id: str, environment: str
-    ) -> AppVariantOutput:
-        """
-        Retrieve the app variant based on the provided app_id and environment.
-
-        Args:
-        app_id (str): The ID of the app to retrieve the variant for.
-        environment (str): The environment of the app variant to retrieve.
-        stoken_session (SessionContainer, optional): The session token container. Defaults to Depends(verify_session()).
-
-        Raises:
-        HTTPException: If the app variant is not found (status_code=500), or if a ValueError is raised (status_code=400), or if any other exception is raised (status_code=500).
-
-        Returns:
-        AppVariantOutput: The retrieved app variant.
-
-        Parameters:
-            - app_id: str.
-
-            - environment: str.
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/", "apps/get_variant_by_env"
-            ),
-            params=remove_none_from_dict(
-                {"app_id": app_id, "environment": environment}
-            ),
-            headers=self._client_wrapper.get_headers(),
-            timeout=60,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(AppVariantOutput, _response.json())  # type: ignore
-        if _response.status_code == 422:
-            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
-        try:
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
     async def list_apps(
         self,
         *,
@@ -3390,6 +3805,11 @@ class AsyncAgentaApi:
             - app_name: str.
 
             - organization_id: typing.Optional[str].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_app(app_name="string")
         """
         _request: typing.Dict[str, typing.Any] = {"app_name": app_name}
         if organization_id is not OMIT:
@@ -3447,6 +3867,11 @@ class AsyncAgentaApi:
             - base_name: typing.Optional[str].
 
             - config_name: typing.Optional[str].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.add_variant_from_image(app_id="string", variant_name="string", docker_id="string", tags="string")
         """
         _request: typing.Dict[str, typing.Any] = {
             "variant_name": variant_name,
@@ -3486,6 +3911,11 @@ class AsyncAgentaApi:
 
         Parameters:
             - app_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.remove_app(app_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "DELETE",
@@ -3534,6 +3964,13 @@ class AsyncAgentaApi:
             - env_vars: typing.Dict[str, str].
 
             - organization_id: typing.Optional[str].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_app_and_variant_from_template(
+            app_name="string", template_id="string", env_vars={"string": "string"}
+        )
         """
         _request: typing.Dict[str, typing.Any] = {
             "app_name": app_name,
@@ -3579,7 +4016,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.list_environments(app_id="app-id")
+        await client.list_environments(app_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -3656,13 +4093,41 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def start_variant(
-        self,
-        variant_id: str,
-        *,
-        action: VariantAction,
-        env_vars: typing.Optional[DockerEnvVars] = OMIT,
-    ) -> Uri:
+    async def get_variant(self, variant_id: str) -> AppVariantOutputExtended:
+        """
+        Parameters:
+            - variant_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_variant(variant_id="string")
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", f"variants/{variant_id}"
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(AppVariantOutputExtended, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def start_variant(
+        self,
+        variant_id: str,
+        *,
+        action: VariantAction,
+        env_vars: typing.Optional[DockerEnvVars] = OMIT,
+    ) -> Uri:
         """
         Start a variant of an app.
 
@@ -3684,6 +4149,16 @@ class AsyncAgentaApi:
             - action: VariantAction.
 
             - env_vars: typing.Optional[DockerEnvVars].
+        ---
+        from agenta import DockerEnvVars, VariantAction, VariantActionEnum
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.start_variant(
+            variant_id="string",
+            action=VariantAction(action=VariantActionEnum.START),
+            env_vars=DockerEnvVars(env_vars={"string": "string"}),
+        )
         """
         _request: typing.Dict[str, typing.Any] = {"action": action}
         if env_vars is not OMIT:
@@ -3720,6 +4195,11 @@ class AsyncAgentaApi:
 
         Parameters:
             - variant_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.remove_variant(variant_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "DELETE",
@@ -3760,6 +4240,13 @@ class AsyncAgentaApi:
             - variant_id: str.
 
             - parameters: typing.Dict[str, typing.Any].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_variant_parameters(
+            variant_id="string", parameters={"string": {"unknown": "string", "type": "unknown"}}
+        )
         """
         _response = await self._client_wrapper.httpx_client.request(
             "PUT",
@@ -3801,6 +4288,12 @@ class AsyncAgentaApi:
             - variant_id: str.
 
             - request: Image.
+        ---
+        from agenta import Image
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_variant_image(variant_id="string", request=Image(docker_id="string", tags="string"))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "PUT",
@@ -3822,7 +4315,9 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def fetch_list_evaluations(self, *, app_id: str) -> typing.List[Evaluation]:
+    async def fetch_list_evaluations_evaluations_get(
+        self, *, app_id: str
+    ) -> typing.List[Evaluation]:
         """
         Fetches a list of evaluations, optionally filtered by an app ID.
 
@@ -3838,7 +4333,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.fetch_list_evaluations(app_id="app-id")
+        await client.fetch_list_evaluations_evaluations_get(app_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -3865,7 +4360,6 @@ class AsyncAgentaApi:
         app_id: str,
         variant_ids: typing.List[str],
         evaluation_type: EvaluationType,
-        evaluation_type_settings: typing.Optional[EvaluationTypeSettings] = OMIT,
         inputs: typing.List[str],
         testset_id: str,
         status: str,
@@ -3884,30 +4378,40 @@ class AsyncAgentaApi:
 
             - evaluation_type: EvaluationType.
 
-            - evaluation_type_settings: typing.Optional[EvaluationTypeSettings].
-
             - inputs: typing.List[str].
 
             - testset_id: str.
 
             - status: str.
+        ---
+        from agenta import EvaluationType
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_evaluation(
+            app_id="string",
+            variant_ids=[],
+            evaluation_type=EvaluationType.HUMAN_A_B_TESTING,
+            inputs=[],
+            testset_id="string",
+            status="string",
+        )
         """
-        _request: typing.Dict[str, typing.Any] = {
-            "app_id": app_id,
-            "variant_ids": variant_ids,
-            "evaluation_type": evaluation_type,
-            "inputs": inputs,
-            "testset_id": testset_id,
-            "status": status,
-        }
-        if evaluation_type_settings is not OMIT:
-            _request["evaluation_type_settings"] = evaluation_type_settings
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/", "evaluations"
+                f"{self._client_wrapper.get_base_url()}/", "human-evaluations"
+            ),
+            json=jsonable_encoder(
+                {
+                    "app_id": app_id,
+                    "variant_ids": variant_ids,
+                    "evaluation_type": evaluation_type,
+                    "inputs": inputs,
+                    "testset_id": testset_id,
+                    "status": status,
+                }
             ),
-            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -3922,7 +4426,7 @@ class AsyncAgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     async def delete_evaluations(
-        self, *, evaluations_ids: typing.List[str]
+        self, *, request: DeleteEvaluation
     ) -> typing.List[str]:
         """
         Delete specific comparison tables based on their unique IDs.
@@ -3934,19 +4438,20 @@ class AsyncAgentaApi:
         A list of the deleted comparison tables' IDs.
 
         Parameters:
-            - evaluations_ids: typing.List[str].
+            - request: DeleteEvaluation.
         ---
+        from agenta import DeleteEvaluation
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.delete_evaluations(evaluations_ids=[])
+        await client.delete_evaluations(request=DeleteEvaluation(evaluations_ids=[]))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "DELETE",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/", "evaluations"
             ),
-            json=jsonable_encoder({"evaluations_ids": evaluations_ids}),
+            json=jsonable_encoder(request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -3960,30 +4465,36 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def fetch_evaluation(self, evaluation_id: str) -> Evaluation:
+    async def fetch_evaluation_status(self, evaluation_id: str) -> typing.Any:
         """
-        Fetches a single evaluation based on its ID.
+        Fetches the status of the evaluation.
 
         Args:
-        evaluation_id (str): The ID of the evaluation to fetch.
+        evaluation_id (str): the evaluation id
+        request (Request): the request object
 
         Returns:
-        Evaluation: The fetched evaluation.
+        (str): the evaluation status
 
         Parameters:
             - evaluation_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_evaluation_status(evaluation_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}",
+                f"evaluations/{evaluation_id}/status",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(Evaluation, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -3992,41 +4503,31 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def update_evaluation(
-        self,
-        evaluation_id: str,
-        *,
-        status: typing.Optional[EvaluationStatusEnum] = OMIT,
-        evaluation_type_settings: typing.Optional[EvaluationTypeSettings] = OMIT,
-    ) -> typing.Any:
+    async def fetch_evaluation_results(self, evaluation_id: str) -> typing.Any:
         """
-        Updates an evaluation's status.
+        Fetches the results of the evaluation
 
-        Raises:
-        HTTPException: If the columns in the test set do not match with the inputs in the variant.
+        Args:
+        evaluation_id (str): the evaluation id
+        request (Request): the request object
 
         Returns:
-        None: A 204 No Content status code, indicating that the update was successful.
+        _type_: _description_
 
         Parameters:
             - evaluation_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
 
-            - status: typing.Optional[EvaluationStatusEnum].
-
-            - evaluation_type_settings: typing.Optional[EvaluationTypeSettings].
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_evaluation_results(evaluation_id="string")
         """
-        _request: typing.Dict[str, typing.Any] = {}
-        if status is not OMIT:
-            _request["status"] = status
-        if evaluation_type_settings is not OMIT:
-            _request["evaluation_type_settings"] = evaluation_type_settings
         _response = await self._client_wrapper.httpx_client.request(
-            "PUT",
+            "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}",
+                f"evaluations/{evaluation_id}/results",
             ),
-            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -4042,7 +4543,116 @@ class AsyncAgentaApi:
 
     async def fetch_evaluation_scenarios(
         self, evaluation_id: str
-    ) -> typing.List[EvaluationScenario]:
+    ) -> typing.List[HumanEvaluationScenario]:
+        """
+        Fetches evaluation scenarios for a given evaluation ID.
+
+        Arguments:
+        evaluation_id (str): The ID of the evaluation for which to fetch scenarios.
+
+        Raises:
+        HTTPException: If the evaluation is not found or access is denied.
+
+        Returns:
+        List[EvaluationScenario]: A list of evaluation scenarios.
+
+        Parameters:
+            - evaluation_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_evaluation_scenarios(evaluation_id="string")
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                f"human-evaluations/{evaluation_id}/evaluation_scenarios",
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[HumanEvaluationScenario], _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def fetch_evaluation(self, evaluation_id: str) -> Evaluation:
+        """
+        Fetches a single evaluation based on its ID.
+
+        Args:
+        evaluation_id (str): The ID of the evaluation to fetch.
+
+        Returns:
+        Evaluation: The fetched evaluation.
+
+        Parameters:
+            - evaluation_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_evaluation(evaluation_id="string")
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                f"evaluations/{evaluation_id}",
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(Evaluation, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def webhook_example_fake(self) -> EvaluationWebhook:
+        """
+        Returns a fake score response for example webhook evaluation
+
+        Returns:
+        _description_
+
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.webhook_example_fake()
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "POST",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                "evaluations/webhook_example_fake",
+            ),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(EvaluationWebhook, _response.json())  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def fetch_evaluation_scenarios_evaluations_evaluation_scenarios_comparison_results_get(
+        self, *, evaluations_ids: str
+    ) -> typing.Any:
         """
         Fetches evaluation scenarios for a given evaluation ID.
 
@@ -4055,25 +4665,146 @@ class AsyncAgentaApi:
         Returns:
         List[EvaluationScenario]: A list of evaluation scenarios.
 
+        Parameters:
+            - evaluations_ids: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_evaluation_scenarios_evaluations_evaluation_scenarios_comparison_results_get(
+            evaluations_ids="string"
+        )
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/",
+                "evaluations/evaluation_scenarios/comparison-results",
+            ),
+            params=remove_none_from_dict({"evaluations_ids": evaluations_ids}),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def fetch_list_human_evaluations_human_evaluations_get(
+        self, *, app_id: str
+    ) -> typing.List[HumanEvaluation]:
+        """
+        Fetches a list of evaluations, optionally filtered by an app ID.
+
+        Args:
+        app_id (Optional[str]): An optional app ID to filter the evaluations.
+
+        Returns:
+        List[HumanEvaluation]: A list of evaluations.
+
+        Parameters:
+            - app_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_list_human_evaluations_human_evaluations_get(app_id="string")
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "GET",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", "human-evaluations"
+            ),
+            params=remove_none_from_dict({"app_id": app_id}),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[HumanEvaluation], _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def delete_evaluations_human_evaluations_delete(
+        self, *, request: DeleteEvaluation
+    ) -> typing.List[str]:
+        """
+        Delete specific comparison tables based on their unique IDs.
+
+        Args:
+        delete_evaluations (List[str]): The unique identifiers of the comparison tables to delete.
+
+        Returns:
+        A list of the deleted comparison tables' IDs.
+
+        Parameters:
+            - request: DeleteEvaluation.
+        ---
+        from agenta import DeleteEvaluation
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.delete_evaluations_human_evaluations_delete(request=DeleteEvaluation(evaluations_ids=[]))
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "DELETE",
+            urllib.parse.urljoin(
+                f"{self._client_wrapper.get_base_url()}/", "human-evaluations"
+            ),
+            json=jsonable_encoder(request),
+            headers=self._client_wrapper.get_headers(),
+            timeout=60,
+        )
+        if 200 <= _response.status_code < 300:
+            return pydantic.parse_obj_as(typing.List[str], _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+        try:
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, body=_response.text)
+        raise ApiError(status_code=_response.status_code, body=_response_json)
+
+    async def fetch_human_evaluation_human_evaluations_evaluation_id_get(
+        self, evaluation_id: str
+    ) -> HumanEvaluation:
+        """
+        Fetches a single evaluation based on its ID.
+
+        Args:
+        evaluation_id (str): The ID of the evaluation to fetch.
+
+        Returns:
+        HumanEvaluation: The fetched evaluation.
+
         Parameters:
             - evaluation_id: str.
         ---
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.fetch_evaluation_scenarios(evaluation_id="evaluation-id")
+        await client.fetch_human_evaluation_human_evaluations_evaluation_id_get(evaluation_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/evaluation_scenarios",
+                f"human-evaluations/{evaluation_id}",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.List[EvaluationScenario], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(HumanEvaluation, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -4082,30 +4813,42 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def create_evaluation_scenario(
-        self, evaluation_id: str, *, request: EvaluationScenario
+    async def update_human_evaluation(
+        self,
+        evaluation_id: str,
+        *,
+        status: typing.Optional[EvaluationStatusEnum] = OMIT,
     ) -> typing.Any:
         """
-        Create a new evaluation scenario for a given evaluation ID.
+        Updates an evaluation's status.
 
         Raises:
-        HTTPException: If evaluation not found or access denied.
+        HTTPException: If the columns in the test set do not match with the inputs in the variant.
 
         Returns:
-        None: 204 No Content status code upon success.
+        None: A 204 No Content status code, indicating that the update was successful.
 
         Parameters:
             - evaluation_id: str.
 
-            - request: EvaluationScenario.
+            - status: typing.Optional[EvaluationStatusEnum].
+        ---
+        from agenta import EvaluationStatusEnum
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_human_evaluation(evaluation_id="string", status=EvaluationStatusEnum.EVALUATION_INITIALIZED)
         """
+        _request: typing.Dict[str, typing.Any] = {}
+        if status is not OMIT:
+            _request["status"] = status
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
+            "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/evaluation_scenario",
+                f"human-evaluations/{evaluation_id}",
             ),
-            json=jsonable_encoder(request),
+            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
@@ -4119,17 +4862,17 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def update_evaluation_scenario(
+    async def update_evaluation_scenario_router_human_evaluations_evaluation_id_evaluation_scenario_evaluation_scenario_id_evaluation_type_put(
         self,
         evaluation_id: str,
         evaluation_scenario_id: str,
         evaluation_type: EvaluationType,
         *,
         vote: typing.Optional[str] = OMIT,
-        score: typing.Optional[EvaluationScenarioUpdateScore] = OMIT,
+        score: typing.Optional[HumanEvaluationScenarioUpdateScore] = OMIT,
         correct_answer: typing.Optional[str] = OMIT,
-        outputs: typing.Optional[typing.List[EvaluationScenarioOutput]] = OMIT,
-        inputs: typing.Optional[typing.List[EvaluationScenarioInput]] = OMIT,
+        outputs: typing.Optional[typing.List[HumanEvaluationScenarioOutput]] = OMIT,
+        inputs: typing.Optional[typing.List[HumanEvaluationScenarioInput]] = OMIT,
         is_pinned: typing.Optional[bool] = OMIT,
         note: typing.Optional[str] = OMIT,
     ) -> typing.Any:
@@ -4151,17 +4894,29 @@ class AsyncAgentaApi:
 
             - vote: typing.Optional[str].
 
-            - score: typing.Optional[EvaluationScenarioUpdateScore].
+            - score: typing.Optional[HumanEvaluationScenarioUpdateScore].
 
             - correct_answer: typing.Optional[str].
 
-            - outputs: typing.Optional[typing.List[EvaluationScenarioOutput]].
+            - outputs: typing.Optional[typing.List[HumanEvaluationScenarioOutput]].
 
-            - inputs: typing.Optional[typing.List[EvaluationScenarioInput]].
+            - inputs: typing.Optional[typing.List[HumanEvaluationScenarioInput]].
 
             - is_pinned: typing.Optional[bool].
 
             - note: typing.Optional[str].
+        ---
+        from agenta import EvaluationType, HumanEvaluationScenarioInput, HumanEvaluationScenarioOutput
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_evaluation_scenario_router_human_evaluations_evaluation_id_evaluation_scenario_evaluation_scenario_id_evaluation_type_put(
+            evaluation_id="string",
+            evaluation_scenario_id="string",
+            evaluation_type=EvaluationType.HUMAN_A_B_TESTING,
+            outputs=[HumanEvaluationScenarioOutput(variant_id="string", variant_output="string")],
+            inputs=[HumanEvaluationScenarioInput(input_name="string", input_value="string")],
+        )
         """
         _request: typing.Dict[str, typing.Any] = {}
         if vote is not OMIT:
@@ -4182,7 +4937,7 @@ class AsyncAgentaApi:
             "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/evaluation_scenario/{evaluation_scenario_id}/{evaluation_type}",
+                f"human-evaluations/{evaluation_id}/evaluation_scenario/{evaluation_scenario_id}/{evaluation_type}",
             ),
             json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
@@ -4198,74 +4953,7 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def evaluate_ai_critique(
-        self,
-        *,
-        correct_answer: str,
-        llm_app_prompt_template: typing.Optional[str] = OMIT,
-        inputs: typing.List[EvaluationScenarioInput],
-        outputs: typing.List[EvaluationScenarioOutput],
-        evaluation_prompt_template: typing.Optional[str] = OMIT,
-        open_ai_key: typing.Optional[str] = OMIT,
-    ) -> str:
-        """
-        Evaluate AI critique based on the given payload.
-
-        Args:
-        payload (AICritiqueCreate): The payload containing data for AI critique evaluation.
-        stoken_session (SessionContainer): The session container verified by `verify_session`.
-
-        Returns:
-        str: The output of the AI critique evaluation.
-
-        Raises:
-        HTTPException: If any exception occurs during the evaluation.
-
-        Parameters:
-            - correct_answer: str.
-
-            - llm_app_prompt_template: typing.Optional[str].
-
-            - inputs: typing.List[EvaluationScenarioInput].
-
-            - outputs: typing.List[EvaluationScenarioOutput].
-
-            - evaluation_prompt_template: typing.Optional[str].
-
-            - open_ai_key: typing.Optional[str].
-        """
-        _request: typing.Dict[str, typing.Any] = {
-            "correct_answer": correct_answer,
-            "inputs": inputs,
-            "outputs": outputs,
-        }
-        if llm_app_prompt_template is not OMIT:
-            _request["llm_app_prompt_template"] = llm_app_prompt_template
-        if evaluation_prompt_template is not OMIT:
-            _request["evaluation_prompt_template"] = evaluation_prompt_template
-        if open_ai_key is not OMIT:
-            _request["open_ai_key"] = open_ai_key
-        _response = await self._client_wrapper.httpx_client.request(
-            "POST",
-            urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                "evaluations/evaluation_scenario/ai_critique",
-            ),
-            json=jsonable_encoder(_request),
-            headers=self._client_wrapper.get_headers(),
-            timeout=60,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(str, _response.json())  # type: ignore
-        if _response.status_code == 422:
-            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
-        try:
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-    async def get_evaluation_scenario_score(
+    async def get_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_get(
         self, evaluation_scenario_id: str
     ) -> typing.Dict[str, str]:
         """
@@ -4284,13 +4972,15 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.get_evaluation_scenario_score(evaluation_scenario_id="evaluation-scenario-id")
+        await client.get_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_get(
+            evaluation_scenario_id="string"
+        )
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
+                f"human-evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
@@ -4305,7 +4995,7 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def update_evaluation_scenario_score(
+    async def update_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_put(
         self, evaluation_scenario_id: str, *, score: float
     ) -> typing.Any:
         """
@@ -4321,12 +5011,19 @@ class AsyncAgentaApi:
             - evaluation_scenario_id: str.
 
             - score: float.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_evaluation_scenario_score_router_human_evaluations_evaluation_scenario_evaluation_scenario_id_score_put(
+            evaluation_scenario_id="string", score=1.1
+        )
         """
         _response = await self._client_wrapper.httpx_client.request(
             "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
+                f"human-evaluations/evaluation_scenario/{evaluation_scenario_id}/score",
             ),
             json=jsonable_encoder({"score": score}),
             headers=self._client_wrapper.get_headers(),
@@ -4354,12 +5051,17 @@ class AsyncAgentaApi:
 
         Parameters:
             - evaluation_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.fetch_results(evaluation_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/{evaluation_id}/results",
+                f"human-evaluations/{evaluation_id}/results",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
@@ -4374,98 +5076,66 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def create_custom_evaluation(
-        self, *, request: CreateCustomEvaluation
-    ) -> typing.Any:
+    async def get_evaluators_endpoint_evaluators_get(self) -> typing.List[Evaluator]:
         """
-        Create evaluation with custom python code.
+        Endpoint to fetch a list of evaluators.
 
-        Args:
+        Returns:
+        List[Evaluator]: A list of evaluator objects.
 
-        custom_evaluation_payload (CreateCustomEvaluation): the required payload
+        ---
+        from agenta.client import AsyncAgentaApi
 
-        Parameters:
-            - request: CreateCustomEvaluation.
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_evaluators_endpoint_evaluators_get()
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
+            "GET",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                "evaluations/custom_evaluation",
+                f"{self._client_wrapper.get_base_url()}/", "evaluators"
             ),
-            json=jsonable_encoder(request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
-        if _response.status_code == 422:
-            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
+            return pydantic.parse_obj_as(typing.List[Evaluator], _response.json())  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def get_custom_evaluation(self, id: str) -> CustomEvaluationDetail:
+    async def get_evaluator_configs_evaluators_configs_get(
+        self, *, app_id: str
+    ) -> typing.List[EvaluatorConfig]:
         """
-        Get the custom code evaluation detail.
+        Endpoint to fetch evaluator configurations for a specific app.
 
         Args:
-        id (str): the id of the custom evaluation
+        app_id (str): The ID of the app.
 
         Returns:
-        CustomEvaluationDetail: Detail of the custom evaluation
-
-        Parameters:
-            - id: str.
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "GET",
-            urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/{id}",
-            ),
-            headers=self._client_wrapper.get_headers(),
-            timeout=60,
-        )
-        if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(CustomEvaluationDetail, _response.json())  # type: ignore
-        if _response.status_code == 422:
-            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
-        try:
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
-
-    async def update_custom_evaluation(
-        self, id: str, *, request: CreateCustomEvaluation
-    ) -> typing.Any:
-        """
-        Update a custom code evaluation.
-        Args:
-        id (str): the ID of the custom evaluation to update
-        updated_data (CreateCustomEvaluation): the payload with updated data
-        stoken_session (SessionContainer): session container for authentication
+        List[EvaluatorConfigDB]: A list of evaluator configuration objects.
 
         Parameters:
-            - id: str.
+            - app_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
 
-            - request: CreateCustomEvaluation.
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_evaluator_configs_evaluators_configs_get(app_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "PUT",
+            "GET",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/{id}",
+                f"{self._client_wrapper.get_base_url()}/", "evaluators/configs"
             ),
-            json=jsonable_encoder(request),
+            params=remove_none_from_dict({"app_id": app_id}),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(typing.List[EvaluatorConfig], _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -4474,37 +5144,60 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def list_custom_evaluations(
-        self, app_id: str
-    ) -> typing.List[CustomEvaluationOutput]:
+    async def create_new_evaluator_config_evaluators_configs_post(
+        self,
+        *,
+        app_id: str,
+        name: str,
+        evaluator_key: str,
+        settings_values: typing.Dict[str, typing.Any],
+    ) -> EvaluatorConfig:
         """
-        List the custom code evaluations for a given app.
+        Endpoint to fetch evaluator configurations for a specific app.
 
         Args:
-        app_id (str): the id of the app
+        app_id (str): The ID of the app.
 
         Returns:
-        List[CustomEvaluationOutput]: a list of custom evaluation
+        EvaluatorConfigDB: Evaluator configuration api model.
 
         Parameters:
             - app_id: str.
+
+            - name: str.
+
+            - evaluator_key: str.
+
+            - settings_values: typing.Dict[str, typing.Any].
         ---
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.list_custom_evaluations(app_id="app-id")
+        await client.create_new_evaluator_config_evaluators_configs_post(
+            app_id="string",
+            name="string",
+            evaluator_key="string",
+            settings_values={"string": {"unknown": "string", "type": "unknown"}},
+        )
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "GET",
+            "POST",
             urllib.parse.urljoin(
-                f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/list/{app_id}",
+                f"{self._client_wrapper.get_base_url()}/", "evaluators/configs"
+            ),
+            json=jsonable_encoder(
+                {
+                    "app_id": app_id,
+                    "name": name,
+                    "evaluator_key": evaluator_key,
+                    "settings_values": settings_values,
+                }
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.List[CustomEvaluationOutput], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(EvaluatorConfig, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -4513,37 +5206,34 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def get_custom_evaluation_names(
-        self, app_name: str
-    ) -> typing.List[CustomEvaluationNames]:
+    async def get_evaluator_config_evaluators_configs_evaluator_config_id_get(
+        self, evaluator_config_id: str
+    ) -> EvaluatorConfig:
         """
-        Get the names of custom evaluation for a given app.
-
-        Args:
-        app_name (str): the name of the app the evaluation belongs to
+        Endpoint to fetch evaluator configurations for a specific app.
 
         Returns:
-        List[CustomEvaluationNames]: the list of name of custom evaluations
+        List[EvaluatorConfigDB]: A list of evaluator configuration objects.
 
         Parameters:
-            - app_name: str.
+            - evaluator_config_id: str.
         ---
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.get_custom_evaluation_names(app_name="app-name")
+        await client.get_evaluator_config_evaluators_configs_evaluator_config_id_get(evaluator_config_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/{app_name}/names",
+                f"evaluators/configs/{evaluator_config_id}",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.List[CustomEvaluationNames], _response.json())  # type: ignore
+            return pydantic.parse_obj_as(EvaluatorConfig, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -4552,59 +5242,53 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def execute_custom_evaluation(
+    async def update_evaluator_config_evaluators_configs_evaluator_config_id_put(
         self,
-        evaluation_id: str,
+        evaluator_config_id: str,
         *,
-        inputs: typing.List[typing.Dict[str, typing.Any]],
-        app_id: str,
-        variant_id: str,
-        correct_answer: str,
-        outputs: typing.List[typing.Dict[str, typing.Any]],
-    ) -> typing.Any:
+        name: typing.Optional[str] = OMIT,
+        evaluator_key: typing.Optional[str] = OMIT,
+        settings_values: typing.Optional[typing.Dict[str, typing.Any]] = OMIT,
+    ) -> EvaluatorConfig:
         """
-        Execute a custom evaluation code.
-
-        Args:
-        evaluation_id (str): the custom evaluation id
-        payload (ExecuteCustomEvaluationCode): the required payload
+        Endpoint to update evaluator configurations for a specific app.
 
         Returns:
-        float: the result of the evaluation custom code
+        List[EvaluatorConfigDB]: A list of evaluator configuration objects.
 
         Parameters:
-            - evaluation_id: str.
-
-            - inputs: typing.List[typing.Dict[str, typing.Any]].
+            - evaluator_config_id: str.
 
-            - app_id: str.
+            - name: typing.Optional[str].
 
-            - variant_id: str.
+            - evaluator_key: typing.Optional[str].
 
-            - correct_answer: str.
+            - settings_values: typing.Optional[typing.Dict[str, typing.Any]].
+        ---
+        from agenta.client import AsyncAgentaApi
 
-            - outputs: typing.List[typing.Dict[str, typing.Any]].
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_evaluator_config_evaluators_configs_evaluator_config_id_put(evaluator_config_id="string")
         """
+        _request: typing.Dict[str, typing.Any] = {}
+        if name is not OMIT:
+            _request["name"] = name
+        if evaluator_key is not OMIT:
+            _request["evaluator_key"] = evaluator_key
+        if settings_values is not OMIT:
+            _request["settings_values"] = settings_values
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
+            "PUT",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                f"evaluations/custom_evaluation/execute/{evaluation_id}",
-            ),
-            json=jsonable_encoder(
-                {
-                    "inputs": inputs,
-                    "app_id": app_id,
-                    "variant_id": variant_id,
-                    "correct_answer": correct_answer,
-                    "outputs": outputs,
-                }
+                f"evaluators/configs/{evaluator_config_id}",
             ),
+            json=jsonable_encoder(_request),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(typing.Any, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(EvaluatorConfig, _response.json())  # type: ignore
         if _response.status_code == 422:
             raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
@@ -4613,24 +5297,39 @@ class AsyncAgentaApi:
             raise ApiError(status_code=_response.status_code, body=_response.text)
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
-    async def webhook_example_fake(self) -> EvaluationWebhook:
+    async def delete_evaluator_config_evaluators_configs_evaluator_config_id_delete(
+        self, evaluator_config_id: str
+    ) -> bool:
         """
-        Returns a fake score response for example webhook evaluation
+        Endpoint to delete a specific evaluator configuration.
+
+        Args:
+        evaluator_config_id (str): The unique identifier of the evaluator configuration.
 
         Returns:
-        _description_
+        bool: True if deletion was successful, False otherwise.
+
+        Parameters:
+            - evaluator_config_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.delete_evaluator_config_evaluators_configs_evaluator_config_id_delete(evaluator_config_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "POST",
+            "DELETE",
             urllib.parse.urljoin(
                 f"{self._client_wrapper.get_base_url()}/",
-                "evaluations/webhook_example_fake",
+                f"evaluators/configs/{evaluator_config_id}",
             ),
             headers=self._client_wrapper.get_headers(),
             timeout=60,
         )
         if 200 <= _response.status_code < 300:
-            return pydantic.parse_obj_as(EvaluationWebhook, _response.json())  # type: ignore
+            return pydantic.parse_obj_as(bool, _response.json())  # type: ignore
+        if _response.status_code == 422:
+            raise UnprocessableEntityError(pydantic.parse_obj_as(HttpValidationError, _response.json()))  # type: ignore
         try:
             _response_json = _response.json()
         except JSONDecodeError:
@@ -4696,6 +5395,12 @@ class AsyncAgentaApi:
 
         Returns:
         dict: The result of the import process.
+
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.import_testset()
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -4733,6 +5438,12 @@ class AsyncAgentaApi:
             - app_id: str.
 
             - request: NewTestset.
+        ---
+        from agenta import NewTestset
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_testset(app_id="string", request=NewTestset(name="string", csvdata=[]))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -4765,6 +5476,11 @@ class AsyncAgentaApi:
 
         Parameters:
             - testset_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_single_testset(testset_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -4801,6 +5517,12 @@ class AsyncAgentaApi:
             - testset_id: str.
 
             - request: NewTestset.
+        ---
+        from agenta import NewTestset
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_testset(testset_id="string", request=NewTestset(name="string", csvdata=[]))
         """
         _response = await self._client_wrapper.httpx_client.request(
             "PUT",
@@ -4839,7 +5561,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.get_testsets(app_id="app-id")
+        await client.get_testsets(app_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -4926,7 +5648,7 @@ class AsyncAgentaApi:
             data=jsonable_encoder({}),
             files={"tar_file": tar_file},
             headers=self._client_wrapper.get_headers(),
-            timeout=60,
+            timeout=600,
         )
         if 200 <= _response.status_code < 300:
             return pydantic.parse_obj_as(Image, _response.json())  # type: ignore
@@ -4949,6 +5671,11 @@ class AsyncAgentaApi:
 
         Parameters:
             - variant_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.restart_container(variant_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -5021,6 +5748,11 @@ class AsyncAgentaApi:
             - base_id: typing.Optional[str].
 
             - variant_id: typing.Optional[str].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.construct_app_container_url()
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5061,6 +5793,11 @@ class AsyncAgentaApi:
             - environment_name: str.
 
             - variant_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.deploy_to_environment(environment_name="string", variant_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",
@@ -5118,6 +5855,19 @@ class AsyncAgentaApi:
             - end_time: dt.datetime.
 
             - spans: typing.List[str].
+        ---
+        import datetime
+
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_trace(
+            latency=1.1,
+            status="string",
+            start_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+            end_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+            spans=[],
+        )
         """
         _request: typing.Dict[str, typing.Any] = {
             "latency": latency,
@@ -5165,7 +5915,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.get_traces(app_id="app-id", variant_id="variant-id")
+        await client.get_traces(app_id="string", variant_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5190,6 +5940,11 @@ class AsyncAgentaApi:
         """
         Parameters:
             - trace_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_single_trace(trace_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5216,6 +5971,11 @@ class AsyncAgentaApi:
             - trace_id: str.
 
             - status: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_trace_status(trace_id="string", status="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "PUT",
@@ -5290,6 +6050,18 @@ class AsyncAgentaApi:
             - cost: typing.Optional[float].
 
             - tags: typing.Optional[typing.List[str]].
+        ---
+        import datetime
+
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_span(
+            event_name="string",
+            start_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+            status="string",
+            end_time=datetime.datetime.fromisoformat("2024-01-15 09:30:00+00:00"),
+        )
         """
         _request: typing.Dict[str, typing.Any] = {
             "event_name": event_name,
@@ -5348,7 +6120,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.get_spans_of_trace(trace_id="trace-id")
+        await client.get_spans_of_trace(trace_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5377,7 +6149,7 @@ class AsyncAgentaApi:
         from agenta.client import AsyncAgentaApi
 
         client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
-        await client.get_feedbacks(trace_id="trace-id")
+        await client.get_feedbacks(trace_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5415,6 +6187,11 @@ class AsyncAgentaApi:
             - score: typing.Optional[float].
 
             - meta: typing.Optional[typing.Dict[str, typing.Any]].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.create_feedback(trace_id="string")
         """
         _request: typing.Dict[str, typing.Any] = {}
         if feedback is not OMIT:
@@ -5449,6 +6226,11 @@ class AsyncAgentaApi:
             - trace_id: str.
 
             - feedback_id: str.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_feedback(trace_id="string", feedback_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5489,6 +6271,11 @@ class AsyncAgentaApi:
             - score: typing.Optional[float].
 
             - meta: typing.Optional[typing.Dict[str, typing.Any]].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.update_feedback(trace_id="string", feedback_id="string", feedback="string")
         """
         _request: typing.Dict[str, typing.Any] = {"feedback": feedback}
         if score is not OMIT:
@@ -5551,6 +6338,12 @@ class AsyncAgentaApi:
         raise ApiError(status_code=_response.status_code, body=_response_json)
 
     async def get_own_org(self) -> OrganizationOutput:
+        """
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_own_org()
+        """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
             urllib.parse.urljoin(
@@ -5628,6 +6421,11 @@ class AsyncAgentaApi:
             - config_name: typing.Optional[str].
 
             - environment_name: typing.Optional[str].
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.get_config(base_id="string")
         """
         _response = await self._client_wrapper.httpx_client.request(
             "GET",
@@ -5669,6 +6467,16 @@ class AsyncAgentaApi:
             - parameters: typing.Dict[str, typing.Any].
 
             - overwrite: bool.
+        ---
+        from agenta.client import AsyncAgentaApi
+
+        client = AsyncAgentaApi(api_key="YOUR_API_KEY", base_url="https://yourhost.com/path/to/api")
+        await client.save_config(
+            base_id="string",
+            config_name="string",
+            parameters={"string": {"unknown": "string", "type": "unknown"}},
+            overwrite=True,
+        )
         """
         _response = await self._client_wrapper.httpx_client.request(
             "POST",