@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.128"
+version = "2.1.129"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 
@@ -1,43 +1,35 @@
 """Json schema to dynamic pydantic model."""
 
-from typing import Any, Dict, List, Optional, Type, Union
+from enum import Enum
+from typing import Any, Dict, List, Type, Union
 
 from pydantic import BaseModel, Field, create_model
 
 
 def jsonschema_to_pydantic(
     schema: dict[str, Any],
-    definitions: Optional[dict[str, Any]] = None,
 ) -> Type[BaseModel]:
     """Convert a schema dict to a pydantic model.
 
-    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for two unresolved issues.
+    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for three unresolved issues.
+      1. Support for title
+      2. Better representation of optionals.
+      3. Support for optional
 
     Args:
         schema: JSON schema.
         definitions: Definitions dict. Defaults to `$def`.
 
     Returns: Pydantic model.
     """
-    title = schema.get("title", "DynamicModel")
-    assert isinstance(title, str), "Title of a model must be a string."
-
-    description = schema.get("description", None)
-
-    # top level schema provides definitions
-    if definitions is None:
-        if "$defs" in schema:
-            definitions = schema["$defs"]
-        elif "definitions" in schema:
-            definitions = schema["definitions"]
-        else:
-            definitions = {}
+    dynamic_type_counter = 0
+    combined_model_counter = 0
 
     def convert_type(prop: dict[str, Any]) -> Any:
+        nonlocal dynamic_type_counter, combined_model_counter
         if "$ref" in prop:
-            ref_path = prop["$ref"].split("/")
-            ref = definitions[ref_path[-1]]
-            return jsonschema_to_pydantic(ref, definitions)
+            # This is the full path. It will be updated in update_forward_refs.
+            return prop["$ref"].split("/")[-1].capitalize()
 
         if "type" in prop:
             type_mapping = {
@@ -52,13 +44,55 @@ def convert_type(prop: dict[str, Any]) -> Any:
 
             type_ = prop["type"]
 
-            if type_ == "array":
+            if "enum" in prop:
+                dynamic_members = {
+                    f"KEY_{i}": value for i, value in enumerate(prop["enum"])
+                }
+
+                base_type: Any = type_mapping.get(type_, Any)
+
+                class DynamicEnum(base_type, Enum):
+                    pass
+
+                type_ = DynamicEnum(prop.get("title", "DynamicEnum"), dynamic_members)  # type: ignore[call-arg]
+                return type_
+            elif type_ == "array":
                 item_type: Any = convert_type(prop.get("items", {}))
-                assert isinstance(item_type, type)
                 return List[item_type]  # noqa F821
             elif type_ == "object":
                 if "properties" in prop:
-                    return jsonschema_to_pydantic(prop, definitions)
+                    if "title" in prop and prop["title"]:
+                        title = prop["title"]
+                    else:
+                        title = f"DynamicType_{dynamic_type_counter}"
+                        dynamic_type_counter += 1
+
+                    fields: dict[str, Any] = {}
+                    required_fields = prop.get("required", [])
+
+                    for name, property in prop.get("properties", {}).items():
+                        pydantic_type = convert_type(property)
+                        field_kwargs = {}
+                        if "default" in property:
+                            field_kwargs["default"] = property["default"]
+                        if name not in required_fields:
+                            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
+                            # If we convert the Optional type back to json schema, it is represented as type | None.
+                            # pydantic_type = Optional[pydantic_type]
+
+                            if "default" not in field_kwargs:
+                                field_kwargs["default"] = None
+                        if "description" in property:
+                            field_kwargs["description"] = property["description"]
+                        if "title" in property:
+                            field_kwargs["title"] = property["title"]
+
+                        fields[name] = (pydantic_type, Field(**field_kwargs))
+
+                    object_model = create_model(title, **fields)
+                    if "description" in prop:
+                        object_model.__doc__ = prop["description"]
+                    return object_model
                 else:
                     return Dict[str, Any]
             else:
@@ -67,9 +101,13 @@ def convert_type(prop: dict[str, Any]) -> Any:
         elif "allOf" in prop:
             combined_fields = {}
             for sub_schema in prop["allOf"]:
-                model = jsonschema_to_pydantic(sub_schema, definitions)
+                model = convert_type(sub_schema)
                 combined_fields.update(model.__annotations__)
-            return create_model("CombinedModel", **combined_fields)
+            combined_model = create_model(
+                f"CombinedModel_{combined_model_counter}", **combined_fields
+            )
+            combined_model_counter += 1
+            return combined_model
 
         elif "anyOf" in prop:
             unioned_types = tuple(
@@ -81,31 +119,10 @@ def convert_type(prop: dict[str, Any]) -> Any:
         else:
             raise ValueError(f"Unsupported schema: {prop}")
 
-    fields: dict[str, Any] = {}
-    required_fields = schema.get("required", [])
-
-    for name, prop in schema.get("properties", {}).items():
-        pydantic_type = convert_type(prop)
-        field_kwargs = {}
-        if "default" in prop:
-            field_kwargs["default"] = prop["default"]
-        if name not in required_fields:
-            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
-            # If we convert the Optional type back to json schema, it is represented as type | None.
-            # pydantic_type = Optional[pydantic_type]
-
-            if "default" not in field_kwargs:
-                field_kwargs["default"] = None
-        if "description" in prop:
-            field_kwargs["description"] = prop["description"]
-        if "title" in prop:
-            field_kwargs["title"] = prop["title"]
-
-        fields[name] = (pydantic_type, Field(**field_kwargs))
-
-    convert_type(schema.get("properties", {}).get("choices", {}))
-
-    model = create_model(title, **fields)
-    if description:
-        model.__doc__ = description
+    namespace: dict[str, Any] = {}
+    for name, definition in schema.get("$defs", schema.get("definitions", {})).items():
+        model = convert_type(definition)
+        namespace[name.capitalize()] = model
+    model = convert_type(schema)
+    model.model_rebuild(force=True, _types_namespace=namespace)
     return model
@@ -1,16 +1,21 @@
+from enum import Enum
 from typing import List, Optional
 
 from pydantic import BaseModel, Field
 
 from uipath.utils.dynamic_schema import jsonschema_to_pydantic
 
 
-def test_dynamic_schema():
+def atest_dynamic_schema():
     # Arrange
     class InnerSchema(BaseModel):
-        """Inner schema description."""
+        """Inner schema description including a self-reference."""
 
-        pass
+        self_reference: Optional["InnerSchema"] = None
+
+    class CustomEnum(str, Enum):
+        KEY_1 = "VALUE_1"
+        KEY_2 = "VALUE_2"
 
     class Schema(BaseModel):
         """Schema description."""
@@ -70,7 +75,7 @@ class Schema(BaseModel):
         )
 
         nested_object: InnerSchema = Field(
-            default=InnerSchema(),
+            default=InnerSchema(self_reference=None),
             title="Nested Object Title",
             description="Nested Object Description",
         )
@@ -85,6 +90,12 @@ class Schema(BaseModel):
             description="List Nested Object Description",
         )
 
+        enum: CustomEnum = Field(
+            default=CustomEnum.KEY_1,
+            title="Enum Title",
+            description="Enum Description",
+        )
+
     schema_json = Schema.model_json_schema()
 
     # Act