erdo 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

erdo/_generated/types.py

@@ -9,9 +9,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 
+# Import TemplateString for Union types
+if False:  # TYPE_CHECKING
+    from erdo.template import TemplateString
+
 
 # ParameterType (from ParameterType in Go)
 class ParameterType(str, Enum):
@@ -290,34 +294,68 @@ class Bot:
     source: str
     key: Optional[str] = None
     persona: Optional[str] = None
-    running_message: Optional[str] = None
-    finished_message: Optional[str] = None
+    running_message: Optional[Union[str, TemplateString]] = None
+    finished_message: Optional[Union[str, TemplateString]] = None
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["name"] = self.name
-        result["description"] = self.description
-        result["code"] = self.code
-        result["file_path"] = self.file_path
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["code"] = self.code.value if hasattr(self.code, "value") else self.code
+        result["file_path"] = (
+            self.file_path.value if hasattr(self.file_path, "value") else self.file_path
+        )
         if self.key is not None:
-            result["key"] = self.key
+            result["key"] = self.key.value if hasattr(self.key, "value") else self.key
         if self.persona is not None:
-            result["persona"] = self.persona
+            result["persona"] = (
+                self.persona.value if hasattr(self.persona, "value") else self.persona
+            )
         if self.running_message is not None:
-            result["running_message"] = self.running_message
+            result["running_message"] = (
+                str(self.running_message)
+                if hasattr(self.running_message, "__str__")
+                else self.running_message
+            )
         if self.finished_message is not None:
-            result["finished_message"] = self.finished_message
+            result["finished_message"] = (
+                str(self.finished_message)
+                if hasattr(self.finished_message, "__str__")
+                else self.finished_message
+            )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
-        result["organization_id"] = self.organization_id
-        result["visibility"] = self.visibility
-        result["source"] = self.source
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
+        result["organization_id"] = (
+            self.organization_id.value
+            if hasattr(self.organization_id, "value")
+            else self.organization_id
+        )
+        result["visibility"] = (
+            self.visibility.value
+            if hasattr(self.visibility, "value")
+            else self.visibility
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         return result
 
 
@@ -341,23 +379,49 @@ class ParameterDefinition:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.bot_id is not None:
-            result["bot_id"] = self.bot_id
-        result["name"] = self.name
-        result["key"] = self.key
+            result["bot_id"] = (
+                self.bot_id.value if hasattr(self.bot_id, "value") else self.bot_id
+            )
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["key"] = self.key.value if hasattr(self.key, "value") else self.key
         if self.description is not None:
-            result["description"] = self.description
-        result["type"] = self.type
-        result["is_required"] = self.is_required
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["is_required"] = (
+            self.is_required.value
+            if hasattr(self.is_required, "value")
+            else self.is_required
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         if self.value_sources is not None:
-            result["value_sources"] = self.value_sources
+            result["value_sources"] = (
+                self.value_sources.value
+                if hasattr(self.value_sources, "value")
+                else self.value_sources
+            )
         if self.interpreters is not None:
-            result["interpreters"] = self.interpreters
+            result["interpreters"] = (
+                self.interpreters.value
+                if hasattr(self.interpreters, "value")
+                else self.interpreters
+            )
         return result
 
 
@@ -377,17 +441,37 @@ class ParameterValueSource:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.parameter_definition_id is not None:
-            result["parameter_definition_id"] = self.parameter_definition_id
-        result["type"] = self.type
-        result["parameters"] = self.parameters
+            result["parameter_definition_id"] = (
+                self.parameter_definition_id.value
+                if hasattr(self.parameter_definition_id, "value")
+                else self.parameter_definition_id
+            )
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         if self.on_populate is not None:
-            result["on_populate"] = self.on_populate
+            result["on_populate"] = (
+                self.on_populate.value
+                if hasattr(self.on_populate, "value")
+                else self.on_populate
+            )
         return result
 
 
@@ -407,16 +491,40 @@ class ParameterValueSourceHandler:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.parameter_value_source_id is not None:
-            result["parameter_value_source_id"] = self.parameter_value_source_id
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
-        result["execution_mode"] = self.execution_mode
+            result["parameter_value_source_id"] = (
+                self.parameter_value_source_id.value
+                if hasattr(self.parameter_value_source_id, "value")
+                else self.parameter_value_source_id
+            )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
+        result["execution_mode"] = (
+            self.execution_mode.value
+            if hasattr(self.execution_mode, "value")
+            else self.execution_mode
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         return result
 
 
@@ -436,55 +544,40 @@ class ParameterInterpreter:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.parameter_definition_id is not None:
-            result["parameter_definition_id"] = self.parameter_definition_id
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
-        result["interpreter_order"] = self.interpreter_order
+            result["parameter_definition_id"] = (
+                self.parameter_definition_id.value
+                if hasattr(self.parameter_definition_id, "value")
+                else self.parameter_definition_id
+            )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
+        result["interpreter_order"] = (
+            self.interpreter_order.value
+            if hasattr(self.interpreter_order, "value")
+            else self.interpreter_order
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
-        return result
-
-
-@dataclass
-class AgentDiscovery:
-    """AgentDiscovery matching Go backend structure."""
-
-    bot: "Bot"
-    parameter_definitions: List["ParameterDefinition"]
-    steps: List["StepWithHandlers"]
-    file_path: str
-    source_code: str
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result = {}
-        result["bot"] = self.bot
-        result["parameter_definitions"] = self.parameter_definitions
-        result["steps"] = self.steps
-        result["file_path"] = self.file_path
-        result["source_code"] = self.source_code
-        return result
-
-
-@dataclass
-class ExecutionModeConfig:
-    """ExecutionMode matching Go backend structure."""
-
-    mode: Any
-    data: Any
-    if_condition: Optional["ConditionDefinition"] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result = {}
-        result["mode"] = self.mode
-        result["data"] = self.data
-        if self.if_condition is not None:
-            result["if_condition"] = self.if_condition
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         return result
 
 
@@ -500,11 +593,19 @@ class UpsertBotRequest:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["bot"] = self.bot
-        result["steps"] = self.steps
-        result["source"] = self.source
+        result["bot"] = self.bot.value if hasattr(self.bot, "value") else self.bot
+        result["steps"] = (
+            self.steps.value if hasattr(self.steps, "value") else self.steps
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         if self.parameter_definitions is not None:
-            result["parameter_definitions"] = self.parameter_definitions
+            result["parameter_definitions"] = (
+                self.parameter_definitions.value
+                if hasattr(self.parameter_definitions, "value")
+                else self.parameter_definitions
+            )
         return result
 
 
@@ -517,7 +618,7 @@ class BotsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["bots"] = self.bots
+        result["bots"] = self.bots.value if hasattr(self.bots, "value") else self.bots
         return result
 
 
@@ -530,7 +631,9 @@ class StepsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["steps"] = self.steps
+        result["steps"] = (
+            self.steps.value if hasattr(self.steps, "value") else self.steps
+        )
         return result
 
 
@@ -545,9 +648,15 @@ class ServiceDefinition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["name"] = self.name
-        result["description"] = self.description
-        result["actions"] = self.actions
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["actions"] = (
+            self.actions.value if hasattr(self.actions, "value") else self.actions
+        )
         return result
 
 
@@ -563,11 +672,23 @@ class ActionDefinition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["name"] = self.name
-        result["description"] = self.description
-        result["parameters"] = self.parameters
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
         if self.result_schema is not None:
-            result["result_schema"] = self.result_schema
+            result["result_schema"] = (
+                self.result_schema.value
+                if hasattr(self.result_schema, "value")
+                else self.result_schema
+            )
         return result
 
 
@@ -585,14 +706,34 @@ class ResultSchema:
         """Convert to dict format expected by backend."""
         result = {}
         if self.description is not None:
-            result["description"] = self.description
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
         if self.required_fields is not None:
-            result["required_fields"] = self.required_fields
+            result["required_fields"] = (
+                self.required_fields.value
+                if hasattr(self.required_fields, "value")
+                else self.required_fields
+            )
         if self.optional_fields is not None:
-            result["optional_fields"] = self.optional_fields
-        result["properties"] = self.properties
+            result["optional_fields"] = (
+                self.optional_fields.value
+                if hasattr(self.optional_fields, "value")
+                else self.optional_fields
+            )
+        result["properties"] = (
+            self.properties.value
+            if hasattr(self.properties, "value")
+            else self.properties
+        )
         if self.examples is not None:
-            result["examples"] = self.examples
+            result["examples"] = (
+                self.examples.value
+                if hasattr(self.examples, "value")
+                else self.examples
+            )
         return result
 
 
@@ -610,17 +751,31 @@ class PropertySchema:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.description is not None:
-            result["description"] = self.description
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
         if self.items is not None:
-            result["items"] = self.items
+            result["items"] = (
+                self.items.value if hasattr(self.items, "value") else self.items
+            )
         if self.properties is not None:
-            result["properties"] = self.properties
+            result["properties"] = (
+                self.properties.value
+                if hasattr(self.properties, "value")
+                else self.properties
+            )
         if self.example is not None:
-            result["example"] = self.example
+            result["example"] = (
+                self.example.value if hasattr(self.example, "value") else self.example
+            )
         if self.enum is not None:
-            result["enum"] = self.enum
+            result["enum"] = (
+                self.enum.value if hasattr(self.enum, "value") else self.enum
+            )
         return result
 
 
@@ -642,18 +797,46 @@ class IntegrationSchema:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["key"] = self.key
-        result["name"] = self.name
-        result["description"] = self.description
-        result["type"] = self.type
-        result["auth_types"] = self.auth_types
-        result["credential_schema"] = self.credential_schema
-        result["available_scopes"] = self.available_scopes
-        result["documentation_url"] = self.documentation_url
+        result["key"] = self.key.value if hasattr(self.key, "value") else self.key
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["auth_types"] = (
+            self.auth_types.value
+            if hasattr(self.auth_types, "value")
+            else self.auth_types
+        )
+        result["credential_schema"] = (
+            self.credential_schema.value
+            if hasattr(self.credential_schema, "value")
+            else self.credential_schema
+        )
+        result["available_scopes"] = (
+            self.available_scopes.value
+            if hasattr(self.available_scopes, "value")
+            else self.available_scopes
+        )
+        result["documentation_url"] = (
+            self.documentation_url.value
+            if hasattr(self.documentation_url, "value")
+            else self.documentation_url
+        )
         if self.codegen_details is not None:
-            result["codegen_details"] = self.codegen_details
+            result["codegen_details"] = (
+                self.codegen_details.value
+                if hasattr(self.codegen_details, "value")
+                else self.codegen_details
+            )
         if self.analysis_details is not None:
-            result["analysis_details"] = self.analysis_details
+            result["analysis_details"] = (
+                self.analysis_details.value
+                if hasattr(self.analysis_details, "value")
+                else self.analysis_details
+            )
         return result
 
 
@@ -668,10 +851,14 @@ class CodegenDetails:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["code"] = self.code
-        result["imports"] = self.imports
+        result["code"] = self.code.value if hasattr(self.code, "value") else self.code
+        result["imports"] = (
+            self.imports.value if hasattr(self.imports, "value") else self.imports
+        )
         if self.hint is not None:
-            result["hint"] = self.hint
+            result["hint"] = (
+                self.hint.value if hasattr(self.hint, "value") else self.hint
+            )
         return result
 
 
@@ -685,8 +872,10 @@ class AnalysisDetails:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["imports"] = self.imports
-        result["code"] = self.code
+        result["imports"] = (
+            self.imports.value if hasattr(self.imports, "value") else self.imports
+        )
+        result["code"] = self.code.value if hasattr(self.code, "value") else self.code
         return result
 
 
@@ -705,16 +894,30 @@ class CredentialSchema:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
-        result["description"] = self.description
-        result["required"] = self.required
-        result["source"] = self.source
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["required"] = (
+            self.required.value if hasattr(self.required, "value") else self.required
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         if self.sensitivity is not None:
-            result["sensitivity"] = self.sensitivity
+            result["sensitivity"] = (
+                self.sensitivity.value
+                if hasattr(self.sensitivity, "value")
+                else self.sensitivity
+            )
         if self.jq is not None:
-            result["jq"] = self.jq
+            result["jq"] = self.jq.value if hasattr(self.jq, "value") else self.jq
         if self.header is not None:
-            result["header"] = self.header
+            result["header"] = (
+                self.header.value if hasattr(self.header, "value") else self.header
+            )
         return result
 
 
@@ -728,8 +931,14 @@ class ExportActionsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["services"] = self.services
-        result["integrations"] = self.integrations
+        result["services"] = (
+            self.services.value if hasattr(self.services, "value") else self.services
+        )
+        result["integrations"] = (
+            self.integrations.value
+            if hasattr(self.integrations, "value")
+            else self.integrations
+        )
         return result
 
 
@@ -744,11 +953,17 @@ class ConditionDefinition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.conditions is not None:
-            result["conditions"] = self.conditions
+            result["conditions"] = (
+                self.conditions.value
+                if hasattr(self.conditions, "value")
+                else self.conditions
+            )
         if self.leaf is not None:
-            result["leaf"] = self.leaf
+            result["leaf"] = (
+                self.leaf.value if hasattr(self.leaf, "value") else self.leaf
+            )
         return result
 
 
@@ -763,53 +978,17 @@ class TempCondition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.conditions is not None:
-            result["conditions"] = self.conditions
+            result["conditions"] = (
+                self.conditions.value
+                if hasattr(self.conditions, "value")
+                else self.conditions
+            )
         if self.leaf is not None:
-            result["leaf"] = self.leaf
-        return result
-
-
-@dataclass
-class StepWithHandlers:
-    """StepWithHandlers matching Go backend structure."""
-
-    step: "Step"
-    result_handlers: List["ResultHandler"]
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result = {}
-        result["step"] = self.step
-        result["result_handlers"] = self.result_handlers
-        return result
-
-
-@dataclass
-class ResultHandler:
-    """ResultHandler matching Go backend structure."""
-
-    type: str
-    if_conditions: "ConditionDefinition"
-    result_handler_order: int
-    output_content_type: str
-    steps: List["StepWithHandlers"]
-    history_content_type: Optional[str] = None
-    ui_content_type: Optional[str] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result = {}
-        result["type"] = self.type
-        result["if_conditions"] = self.if_conditions
-        result["result_handler_order"] = self.result_handler_order
-        result["output_content_type"] = self.output_content_type
-        if self.history_content_type is not None:
-            result["history_content_type"] = self.history_content_type
-        if self.ui_content_type is not None:
-            result["ui_content_type"] = self.ui_content_type
-        result["steps"] = self.steps
+            result["leaf"] = (
+                self.leaf.value if hasattr(self.leaf, "value") else self.leaf
+            )
         return result
 
 
@@ -825,13 +1004,21 @@ class JSONSchemaProperty:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.description is not None:
-            result["description"] = self.description
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
         if self.items is not None:
-            result["items"] = self.items
+            result["items"] = (
+                self.items.value if hasattr(self.items, "value") else self.items
+            )
         if self.enum is not None:
-            result["enum"] = self.enum
+            result["enum"] = (
+                self.enum.value if hasattr(self.enum, "value") else self.enum
+            )
         return result
 
 
@@ -847,13 +1034,23 @@ class JSONSchema:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.properties is not None:
-            result["properties"] = self.properties
+            result["properties"] = (
+                self.properties.value
+                if hasattr(self.properties, "value")
+                else self.properties
+            )
         if self.required is not None:
-            result["required"] = self.required
+            result["required"] = (
+                self.required.value
+                if hasattr(self.required, "value")
+                else self.required
+            )
         if self.items is not None:
-            result["items"] = self.items
+            result["items"] = (
+                self.items.value if hasattr(self.items, "value") else self.items
+            )
         return result
 
 
@@ -870,29 +1067,67 @@ class Tool:
     history_content_type: str = None
     ui_content_type: str = None
     as_root: bool = None
-    running_message: Optional[str] = None
-    finished_message: Optional[str] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result = {}
-        result["name"] = self.name
-        result["description"] = self.description
-        result["input_schema"] = self.input_schema
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
+    running_message: Optional[Union[str, TemplateString]] = None
+    finished_message: Optional[Union[str, TemplateString]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        result = {}
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["input_schema"] = (
+            self.input_schema.value
+            if hasattr(self.input_schema, "value")
+            else self.input_schema
+        )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
         if self.bot_output_visibility is not None:
-            result["bot_output_visibility"] = self.bot_output_visibility
+            result["bot_output_visibility"] = (
+                self.bot_output_visibility.value
+                if hasattr(self.bot_output_visibility, "value")
+                else self.bot_output_visibility
+            )
         if self.history_content_type is not None:
-            result["history_content_type"] = self.history_content_type
+            result["history_content_type"] = (
+                self.history_content_type.value
+                if hasattr(self.history_content_type, "value")
+                else self.history_content_type
+            )
         if self.ui_content_type is not None:
-            result["ui_content_type"] = self.ui_content_type
+            result["ui_content_type"] = (
+                self.ui_content_type.value
+                if hasattr(self.ui_content_type, "value")
+                else self.ui_content_type
+            )
         if self.as_root is not None:
-            result["as_root"] = self.as_root
+            result["as_root"] = (
+                self.as_root.value if hasattr(self.as_root, "value") else self.as_root
+            )
         if self.running_message is not None:
-            result["running_message"] = self.running_message
+            result["running_message"] = (
+                str(self.running_message)
+                if hasattr(self.running_message, "__str__")
+                else self.running_message
+            )
         if self.finished_message is not None:
-            result["finished_message"] = self.finished_message
+            result["finished_message"] = (
+                str(self.finished_message)
+                if hasattr(self.finished_message, "__str__")
+                else self.finished_message
+            )
         return result
 
 
@@ -908,11 +1143,17 @@ class Message:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["role"] = self.role
-        result["content"] = self.content
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["role"] = self.role.value if hasattr(self.role, "value") else self.role
+        result["content"] = (
+            self.content.value if hasattr(self.content, "value") else self.content
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         return result
 
 
@@ -931,13 +1172,37 @@ class SystemParameters:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["current_date"] = self.current_date
-        result["messages"] = self.messages
-        result["session_messages"] = self.session_messages
-        result["current_message"] = self.current_message
-        result["thread_id"] = self.thread_id
-        result["organization_id"] = self.organization_id
-        result["invocation_id"] = self.invocation_id
+        result["current_date"] = (
+            self.current_date.value
+            if hasattr(self.current_date, "value")
+            else self.current_date
+        )
+        result["messages"] = (
+            self.messages.value if hasattr(self.messages, "value") else self.messages
+        )
+        result["session_messages"] = (
+            self.session_messages.value
+            if hasattr(self.session_messages, "value")
+            else self.session_messages
+        )
+        result["current_message"] = (
+            self.current_message.value
+            if hasattr(self.current_message, "value")
+            else self.current_message
+        )
+        result["thread_id"] = (
+            self.thread_id.value if hasattr(self.thread_id, "value") else self.thread_id
+        )
+        result["organization_id"] = (
+            self.organization_id.value
+            if hasattr(self.organization_id, "value")
+            else self.organization_id
+        )
+        result["invocation_id"] = (
+            self.invocation_id.value
+            if hasattr(self.invocation_id, "value")
+            else self.invocation_id
+        )
         return result
 
 
@@ -954,15 +1219,27 @@ class Result:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["status"] = self.status
+        result["status"] = (
+            self.status.value if hasattr(self.status, "value") else self.status
+        )
         if self.parameters is not None:
-            result["parameters"] = self.parameters
+            result["parameters"] = (
+                self.parameters.value
+                if hasattr(self.parameters, "value")
+                else self.parameters
+            )
         if self.output is not None:
-            result["output"] = self.output
+            result["output"] = (
+                self.output.value if hasattr(self.output, "value") else self.output
+            )
         if self.message is not None:
-            result["message"] = self.message
+            result["message"] = (
+                self.message.value if hasattr(self.message, "value") else self.message
+            )
         if self.error is not None:
-            result["error"] = self.error
+            result["error"] = (
+                self.error.value if hasattr(self.error, "value") else self.error
+            )
         return result
 
 
@@ -983,8 +1260,8 @@ class APIStep:
     output_channels: List[str]
     depends_on: Optional[List[str]] = None
     key: Optional[str] = None
-    running_message: Optional[str] = None
-    finished_message: Optional[str] = None
+    running_message: Optional[Union[str, TemplateString]] = None
+    finished_message: Optional[Union[str, TemplateString]] = None
     history_content_type: Optional[str] = None
     ui_content_type: Optional[str] = None
     parameter_hydration_behaviour: Optional[Any] = None
@@ -995,37 +1272,111 @@ class APIStep:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["bot_id"] = self.bot_id
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["bot_id"] = (
+            self.bot_id.value if hasattr(self.bot_id, "value") else self.bot_id
+        )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
         if self.depends_on is not None:
-            result["depends_on"] = self.depends_on
+            result["depends_on"] = (
+                self.depends_on.value
+                if hasattr(self.depends_on, "value")
+                else self.depends_on
+            )
         if self.key is not None:
-            result["key"] = self.key
-        result["step_order"] = self.step_order
-        result["output_content_type"] = self.output_content_type
-        result["user_output_visibility"] = self.user_output_visibility
-        result["bot_output_visibility"] = self.bot_output_visibility
-        result["execution_mode"] = self.execution_mode
-        result["output_behaviour"] = self.output_behaviour
-        result["output_channels"] = self.output_channels
+            result["key"] = self.key.value if hasattr(self.key, "value") else self.key
+        result["step_order"] = (
+            self.step_order.value
+            if hasattr(self.step_order, "value")
+            else self.step_order
+        )
+        result["output_content_type"] = (
+            self.output_content_type.value
+            if hasattr(self.output_content_type, "value")
+            else self.output_content_type
+        )
+        result["user_output_visibility"] = (
+            self.user_output_visibility.value
+            if hasattr(self.user_output_visibility, "value")
+            else self.user_output_visibility
+        )
+        result["bot_output_visibility"] = (
+            self.bot_output_visibility.value
+            if hasattr(self.bot_output_visibility, "value")
+            else self.bot_output_visibility
+        )
+        result["execution_mode"] = (
+            self.execution_mode.value
+            if hasattr(self.execution_mode, "value")
+            else self.execution_mode
+        )
+        result["output_behaviour"] = (
+            self.output_behaviour.value
+            if hasattr(self.output_behaviour, "value")
+            else self.output_behaviour
+        )
+        result["output_channels"] = (
+            self.output_channels.value
+            if hasattr(self.output_channels, "value")
+            else self.output_channels
+        )
         if self.running_message is not None:
-            result["running_message"] = self.running_message
+            result["running_message"] = (
+                str(self.running_message)
+                if hasattr(self.running_message, "__str__")
+                else self.running_message
+            )
         if self.finished_message is not None:
-            result["finished_message"] = self.finished_message
+            result["finished_message"] = (
+                str(self.finished_message)
+                if hasattr(self.finished_message, "__str__")
+                else self.finished_message
+            )
         if self.history_content_type is not None:
-            result["history_content_type"] = self.history_content_type
+            result["history_content_type"] = (
+                self.history_content_type.value
+                if hasattr(self.history_content_type, "value")
+                else self.history_content_type
+            )
         if self.ui_content_type is not None:
-            result["ui_content_type"] = self.ui_content_type
+            result["ui_content_type"] = (
+                self.ui_content_type.value
+                if hasattr(self.ui_content_type, "value")
+                else self.ui_content_type
+            )
         if self.parameter_hydration_behaviour is not None:
-            result["parameter_hydration_behaviour"] = self.parameter_hydration_behaviour
+            result["parameter_hydration_behaviour"] = (
+                self.parameter_hydration_behaviour.value
+                if hasattr(self.parameter_hydration_behaviour, "value")
+                else self.parameter_hydration_behaviour
+            )
         if self.result_handler_id is not None:
-            result["result_handler_id"] = self.result_handler_id
+            result["result_handler_id"] = (
+                self.result_handler_id.value
+                if hasattr(self.result_handler_id, "value")
+                else self.result_handler_id
+            )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         return result
 
 
@@ -1045,17 +1396,37 @@ class APIParameterValueSource:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.parameter_definition_id is not None:
-            result["parameter_definition_id"] = self.parameter_definition_id
-        result["type"] = self.type
-        result["parameters"] = self.parameters
+            result["parameter_definition_id"] = (
+                self.parameter_definition_id.value
+                if hasattr(self.parameter_definition_id, "value")
+                else self.parameter_definition_id
+            )
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         if self.on_populate is not None:
-            result["on_populate"] = self.on_populate
+            result["on_populate"] = (
+                self.on_populate.value
+                if hasattr(self.on_populate, "value")
+                else self.on_populate
+            )
         return result
 
 
@@ -1075,16 +1446,40 @@ class APIParameterValueSourceHandler:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.parameter_value_source_id is not None:
-            result["parameter_value_source_id"] = self.parameter_value_source_id
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
-        result["execution_mode"] = self.execution_mode
+            result["parameter_value_source_id"] = (
+                self.parameter_value_source_id.value
+                if hasattr(self.parameter_value_source_id, "value")
+                else self.parameter_value_source_id
+            )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
+        result["execution_mode"] = (
+            self.execution_mode.value
+            if hasattr(self.execution_mode, "value")
+            else self.execution_mode
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         return result
 
 
@@ -1104,16 +1499,40 @@ class APIParameterInterpreter:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.parameter_definition_id is not None:
-            result["parameter_definition_id"] = self.parameter_definition_id
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
-        result["interpreter_order"] = self.interpreter_order
+            result["parameter_definition_id"] = (
+                self.parameter_definition_id.value
+                if hasattr(self.parameter_definition_id, "value")
+                else self.parameter_definition_id
+            )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
+        result["interpreter_order"] = (
+            self.interpreter_order.value
+            if hasattr(self.interpreter_order, "value")
+            else self.interpreter_order
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         return result
 
 
@@ -1128,10 +1547,14 @@ class APIExecutionMode:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["mode"] = self.mode
-        result["data"] = self.data
+        result["mode"] = self.mode.value if hasattr(self.mode, "value") else self.mode
+        result["data"] = self.data.value if hasattr(self.data, "value") else self.data
         if self.if_condition is not None:
-            result["if_condition"] = self.if_condition
+            result["if_condition"] = (
+                self.if_condition.value
+                if hasattr(self.if_condition, "value")
+                else self.if_condition
+            )
         return result
 
 
@@ -1146,11 +1569,17 @@ class APIConditionDefinition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.conditions is not None:
-            result["conditions"] = self.conditions
+            result["conditions"] = (
+                self.conditions.value
+                if hasattr(self.conditions, "value")
+                else self.conditions
+            )
         if self.leaf is not None:
-            result["leaf"] = self.leaf
+            result["leaf"] = (
+                self.leaf.value if hasattr(self.leaf, "value") else self.leaf
+            )
         return result
 
 
@@ -1167,29 +1596,67 @@ class APITool:
     history_content_type: str = None
     ui_content_type: str = None
     as_root: bool = None
-    running_message: Optional[str] = None
-    finished_message: Optional[str] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        result = {}
-        result["name"] = self.name
-        result["description"] = self.description
-        result["input_schema"] = self.input_schema
-        result["action_type"] = self.action_type
-        result["parameters"] = self.parameters
+    running_message: Optional[Union[str, TemplateString]] = None
+    finished_message: Optional[Union[str, TemplateString]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        result = {}
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["input_schema"] = (
+            self.input_schema.value
+            if hasattr(self.input_schema, "value")
+            else self.input_schema
+        )
+        result["action_type"] = (
+            self.action_type.value
+            if hasattr(self.action_type, "value")
+            else self.action_type
+        )
+        result["parameters"] = (
+            self.parameters.value
+            if hasattr(self.parameters, "value")
+            else self.parameters
+        )
         if self.bot_output_visibility is not None:
-            result["bot_output_visibility"] = self.bot_output_visibility
+            result["bot_output_visibility"] = (
+                self.bot_output_visibility.value
+                if hasattr(self.bot_output_visibility, "value")
+                else self.bot_output_visibility
+            )
         if self.history_content_type is not None:
-            result["history_content_type"] = self.history_content_type
+            result["history_content_type"] = (
+                self.history_content_type.value
+                if hasattr(self.history_content_type, "value")
+                else self.history_content_type
+            )
         if self.ui_content_type is not None:
-            result["ui_content_type"] = self.ui_content_type
+            result["ui_content_type"] = (
+                self.ui_content_type.value
+                if hasattr(self.ui_content_type, "value")
+                else self.ui_content_type
+            )
         if self.as_root is not None:
-            result["as_root"] = self.as_root
+            result["as_root"] = (
+                self.as_root.value if hasattr(self.as_root, "value") else self.as_root
+            )
         if self.running_message is not None:
-            result["running_message"] = self.running_message
+            result["running_message"] = (
+                str(self.running_message)
+                if hasattr(self.running_message, "__str__")
+                else self.running_message
+            )
         if self.finished_message is not None:
-            result["finished_message"] = self.finished_message
+            result["finished_message"] = (
+                str(self.finished_message)
+                if hasattr(self.finished_message, "__str__")
+                else self.finished_message
+            )
         return result
 
 
@@ -1208,15 +1675,37 @@ class APIResultHandler:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
-        result["if_conditions"] = self.if_conditions
-        result["result_handler_order"] = self.result_handler_order
-        result["output_content_type"] = self.output_content_type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["if_conditions"] = (
+            self.if_conditions.value
+            if hasattr(self.if_conditions, "value")
+            else self.if_conditions
+        )
+        result["result_handler_order"] = (
+            self.result_handler_order.value
+            if hasattr(self.result_handler_order, "value")
+            else self.result_handler_order
+        )
+        result["output_content_type"] = (
+            self.output_content_type.value
+            if hasattr(self.output_content_type, "value")
+            else self.output_content_type
+        )
         if self.history_content_type is not None:
-            result["history_content_type"] = self.history_content_type
+            result["history_content_type"] = (
+                self.history_content_type.value
+                if hasattr(self.history_content_type, "value")
+                else self.history_content_type
+            )
         if self.ui_content_type is not None:
-            result["ui_content_type"] = self.ui_content_type
-        result["steps"] = self.steps
+            result["ui_content_type"] = (
+                self.ui_content_type.value
+                if hasattr(self.ui_content_type, "value")
+                else self.ui_content_type
+            )
+        result["steps"] = (
+            self.steps.value if hasattr(self.steps, "value") else self.steps
+        )
         return result
 
 
@@ -1238,19 +1727,37 @@ class APIParameterDefinition:
         """Convert to dict format expected by backend."""
         result = {}
         if self.id is not None:
-            result["id"] = self.id
+            result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.bot_id is not None:
-            result["bot_id"] = self.bot_id
-        result["name"] = self.name
-        result["key"] = self.key
+            result["bot_id"] = (
+                self.bot_id.value if hasattr(self.bot_id, "value") else self.bot_id
+            )
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["key"] = self.key.value if hasattr(self.key, "value") else self.key
         if self.description is not None:
-            result["description"] = self.description
-        result["type"] = self.type
-        result["is_required"] = self.is_required
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["is_required"] = (
+            self.is_required.value
+            if hasattr(self.is_required, "value")
+            else self.is_required
+        )
         if self.created_at is not None:
-            result["created_at"] = self.created_at
+            result["created_at"] = (
+                self.created_at.value
+                if hasattr(self.created_at, "value")
+                else self.created_at
+            )
         if self.updated_at is not None:
-            result["updated_at"] = self.updated_at
+            result["updated_at"] = (
+                self.updated_at.value
+                if hasattr(self.updated_at, "value")
+                else self.updated_at
+            )
         return result
 
 
@@ -1264,8 +1771,12 @@ class APIStepWithHandlers:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["step"] = self.step
-        result["result_handlers"] = self.result_handlers
+        result["step"] = self.step.value if hasattr(self.step, "value") else self.step
+        result["result_handlers"] = (
+            self.result_handlers.value
+            if hasattr(self.result_handlers, "value")
+            else self.result_handlers
+        )
         return result
 
 
@@ -1298,48 +1809,110 @@ class Dataset:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["type"] = self.type
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.key is not None:
-            result["key"] = self.key
+            result["key"] = self.key.value if hasattr(self.key, "value") else self.key
         if self.name is not None:
-            result["name"] = self.name
+            result["name"] = (
+                self.name.value if hasattr(self.name, "value") else self.name
+            )
         if self.description is not None:
-            result["description"] = self.description
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
         if self.analysis_summary is not None:
-            result["analysis_summary"] = self.analysis_summary
+            result["analysis_summary"] = (
+                self.analysis_summary.value
+                if hasattr(self.analysis_summary, "value")
+                else self.analysis_summary
+            )
         if self.last_analyzed is not None:
-            result["last_analyzed"] = self.last_analyzed
+            result["last_analyzed"] = (
+                self.last_analyzed.value
+                if hasattr(self.last_analyzed, "value")
+                else self.last_analyzed
+            )
         if self.instructions is not None:
-            result["instructions"] = self.instructions
+            result["instructions"] = (
+                self.instructions.value
+                if hasattr(self.instructions, "value")
+                else self.instructions
+            )
         if self.file is not None:
-            result["file"] = self.file
+            result["file"] = (
+                self.file.value if hasattr(self.file, "value") else self.file
+            )
         if self.file_type is not None:
-            result["file_type"] = self.file_type
+            result["file_type"] = (
+                self.file_type.value
+                if hasattr(self.file_type, "value")
+                else self.file_type
+            )
         if self.filename is not None:
-            result["filename"] = self.filename
+            result["filename"] = (
+                self.filename.value
+                if hasattr(self.filename, "value")
+                else self.filename
+            )
         if self.url is not None:
-            result["url"] = self.url
+            result["url"] = self.url.value if hasattr(self.url, "value") else self.url
         if self.integration_id is not None:
-            result["integration_id"] = self.integration_id
+            result["integration_id"] = (
+                self.integration_id.value
+                if hasattr(self.integration_id, "value")
+                else self.integration_id
+            )
         if self.integration_config_id is not None:
-            result["integration_config_id"] = self.integration_config_id
+            result["integration_config_id"] = (
+                self.integration_config_id.value
+                if hasattr(self.integration_config_id, "value")
+                else self.integration_config_id
+            )
         if self.integration_config is not None:
-            result["integration_config"] = self.integration_config
+            result["integration_config"] = (
+                self.integration_config.value
+                if hasattr(self.integration_config, "value")
+                else self.integration_config
+            )
         if self.encrypted_integration_credentials is not None:
             result["encrypted_integration_credentials"] = (
-                self.encrypted_integration_credentials
+                self.encrypted_integration_credentials.value
+                if hasattr(self.encrypted_integration_credentials, "value")
+                else self.encrypted_integration_credentials
             )
         if self.credential_schema is not None:
-            result["credential_schema"] = self.credential_schema
+            result["credential_schema"] = (
+                self.credential_schema.value
+                if hasattr(self.credential_schema, "value")
+                else self.credential_schema
+            )
         if self.codegen_details is not None:
-            result["codegen_details"] = self.codegen_details
+            result["codegen_details"] = (
+                self.codegen_details.value
+                if hasattr(self.codegen_details, "value")
+                else self.codegen_details
+            )
         if self.analysis_details is not None:
-            result["analysis_details"] = self.analysis_details
+            result["analysis_details"] = (
+                self.analysis_details.value
+                if hasattr(self.analysis_details, "value")
+                else self.analysis_details
+            )
         if self.available_scopes is not None:
-            result["available_scopes"] = self.available_scopes
+            result["available_scopes"] = (
+                self.available_scopes.value
+                if hasattr(self.available_scopes, "value")
+                else self.available_scopes
+            )
         if self.parameters is not None:
-            result["parameters"] = self.parameters
+            result["parameters"] = (
+                self.parameters.value
+                if hasattr(self.parameters, "value")
+                else self.parameters
+            )
         return result
 
 
@@ -1355,11 +1928,19 @@ class BotResource:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
         if self.dataset is not None:
-            result["dataset"] = self.dataset
-        result["created_by"] = self.created_by
-        result["extra"] = self.extra
+            result["dataset"] = (
+                self.dataset.value if hasattr(self.dataset, "value") else self.dataset
+            )
+        result["created_by"] = (
+            self.created_by.value
+            if hasattr(self.created_by, "value")
+            else self.created_by
+        )
+        result["extra"] = (
+            self.extra.value if hasattr(self.extra, "value") else self.extra
+        )
         return result
 
 
@@ -1373,8 +1954,8 @@ class UIConfigIcon:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["set"] = self.set
-        result["name"] = self.name
+        result["set"] = self.set.value if hasattr(self.set, "value") else self.set
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
         return result
 
 
@@ -1389,9 +1970,21 @@ class UIConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["brand_logo_icon"] = self.brand_logo_icon
-        result["brand_color"] = self.brand_color
-        result["button_style"] = self.button_style
+        result["brand_logo_icon"] = (
+            self.brand_logo_icon.value
+            if hasattr(self.brand_logo_icon, "value")
+            else self.brand_logo_icon
+        )
+        result["brand_color"] = (
+            self.brand_color.value
+            if hasattr(self.brand_color, "value")
+            else self.brand_color
+        )
+        result["button_style"] = (
+            self.button_style.value
+            if hasattr(self.button_style, "value")
+            else self.button_style
+        )
         return result
 
 
@@ -1406,9 +1999,17 @@ class ErrorHandlingConfig:
         """Convert to dict format expected by backend."""
         result = {}
         if self.ignore_errors is not None:
-            result["ignore_errors"] = self.ignore_errors
+            result["ignore_errors"] = (
+                self.ignore_errors.value
+                if hasattr(self.ignore_errors, "value")
+                else self.ignore_errors
+            )
         if self.error_path is not None:
-            result["error_path"] = self.error_path
+            result["error_path"] = (
+                self.error_path.value
+                if hasattr(self.error_path, "value")
+                else self.error_path
+            )
         return result
 
 
@@ -1431,25 +2032,55 @@ class SegmentLevel:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["name"] = self.name
-        result["type"] = self.type
-        result["selectable"] = self.selectable
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["selectable"] = (
+            self.selectable.value
+            if hasattr(self.selectable, "value")
+            else self.selectable
+        )
         if self.url_template is not None:
-            result["url_template"] = self.url_template
+            result["url_template"] = (
+                self.url_template.value
+                if hasattr(self.url_template, "value")
+                else self.url_template
+            )
         if self.method is not None:
-            result["method"] = self.method
+            result["method"] = (
+                self.method.value if hasattr(self.method, "value") else self.method
+            )
         if self.body is not None:
-            result["body"] = self.body
+            result["body"] = (
+                self.body.value if hasattr(self.body, "value") else self.body
+            )
         if self.id_path is not None:
-            result["id_path"] = self.id_path
+            result["id_path"] = (
+                self.id_path.value if hasattr(self.id_path, "value") else self.id_path
+            )
         if self.id_regex is not None:
-            result["id_regex"] = self.id_regex
+            result["id_regex"] = (
+                self.id_regex.value
+                if hasattr(self.id_regex, "value")
+                else self.id_regex
+            )
         if self.name_path is not None:
-            result["name_path"] = self.name_path
+            result["name_path"] = (
+                self.name_path.value
+                if hasattr(self.name_path, "value")
+                else self.name_path
+            )
         if self.parent_key is not None:
-            result["parent_key"] = self.parent_key
+            result["parent_key"] = (
+                self.parent_key.value
+                if hasattr(self.parent_key, "value")
+                else self.parent_key
+            )
         if self.required_credentials is not None:
-            result["required_credentials"] = self.required_credentials
+            result["required_credentials"] = (
+                self.required_credentials.value
+                if hasattr(self.required_credentials, "value")
+                else self.required_credentials
+            )
         return result
 
 
@@ -1469,18 +2100,48 @@ class SegmentConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["selection_type"] = self.selection_type
+        result["selection_type"] = (
+            self.selection_type.value
+            if hasattr(self.selection_type, "value")
+            else self.selection_type
+        )
         if self.min_selections is not None:
-            result["min_selections"] = self.min_selections
+            result["min_selections"] = (
+                self.min_selections.value
+                if hasattr(self.min_selections, "value")
+                else self.min_selections
+            )
         if self.max_selections is not None:
-            result["max_selections"] = self.max_selections
-        result["description"] = self.description
-        result["hierarchical"] = self.hierarchical
+            result["max_selections"] = (
+                self.max_selections.value
+                if hasattr(self.max_selections, "value")
+                else self.max_selections
+            )
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["hierarchical"] = (
+            self.hierarchical.value
+            if hasattr(self.hierarchical, "value")
+            else self.hierarchical
+        )
         if self.base_url is not None:
-            result["base_url"] = self.base_url
-        result["levels"] = self.levels
+            result["base_url"] = (
+                self.base_url.value
+                if hasattr(self.base_url, "value")
+                else self.base_url
+            )
+        result["levels"] = (
+            self.levels.value if hasattr(self.levels, "value") else self.levels
+        )
         if self.error_handling is not None:
-            result["error_handling"] = self.error_handling
+            result["error_handling"] = (
+                self.error_handling.value
+                if hasattr(self.error_handling, "value")
+                else self.error_handling
+            )
         return result
 
 
@@ -1499,16 +2160,32 @@ class ResourceTypeConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
-        result["url_template"] = self.url_template
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["url_template"] = (
+            self.url_template.value
+            if hasattr(self.url_template, "value")
+            else self.url_template
+        )
         if self.method is not None:
-            result["method"] = self.method
+            result["method"] = (
+                self.method.value if hasattr(self.method, "value") else self.method
+            )
         if self.body is not None:
-            result["body"] = self.body
-        result["id_path"] = self.id_path
-        result["name_path"] = self.name_path
+            result["body"] = (
+                self.body.value if hasattr(self.body, "value") else self.body
+            )
+        result["id_path"] = (
+            self.id_path.value if hasattr(self.id_path, "value") else self.id_path
+        )
+        result["name_path"] = (
+            self.name_path.value if hasattr(self.name_path, "value") else self.name_path
+        )
         if self.description_path is not None:
-            result["description_path"] = self.description_path
+            result["description_path"] = (
+                self.description_path.value
+                if hasattr(self.description_path, "value")
+                else self.description_path
+            )
         return result
 
 
@@ -1530,25 +2207,65 @@ class DatasetResourceDiscoveryConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["min_resources_required"] = self.min_resources_required
+        result["min_resources_required"] = (
+            self.min_resources_required.value
+            if hasattr(self.min_resources_required, "value")
+            else self.min_resources_required
+        )
         if self.table_query is not None:
-            result["table_query"] = self.table_query
+            result["table_query"] = (
+                self.table_query.value
+                if hasattr(self.table_query, "value")
+                else self.table_query
+            )
         if self.relationship_query is not None:
-            result["relationship_query"] = self.relationship_query
+            result["relationship_query"] = (
+                self.relationship_query.value
+                if hasattr(self.relationship_query, "value")
+                else self.relationship_query
+            )
         if self.index_query is not None:
-            result["index_query"] = self.index_query
+            result["index_query"] = (
+                self.index_query.value
+                if hasattr(self.index_query, "value")
+                else self.index_query
+            )
         if self.constraint_query is not None:
-            result["constraint_query"] = self.constraint_query
+            result["constraint_query"] = (
+                self.constraint_query.value
+                if hasattr(self.constraint_query, "value")
+                else self.constraint_query
+            )
         if self.statistics_query is not None:
-            result["statistics_query"] = self.statistics_query
+            result["statistics_query"] = (
+                self.statistics_query.value
+                if hasattr(self.statistics_query, "value")
+                else self.statistics_query
+            )
         if self.size_query is not None:
-            result["size_query"] = self.size_query
+            result["size_query"] = (
+                self.size_query.value
+                if hasattr(self.size_query, "value")
+                else self.size_query
+            )
         if self.base_url is not None:
-            result["base_url"] = self.base_url
+            result["base_url"] = (
+                self.base_url.value
+                if hasattr(self.base_url, "value")
+                else self.base_url
+            )
         if self.resource_types is not None:
-            result["resource_types"] = self.resource_types
+            result["resource_types"] = (
+                self.resource_types.value
+                if hasattr(self.resource_types, "value")
+                else self.resource_types
+            )
         if self.error_handling is not None:
-            result["error_handling"] = self.error_handling
+            result["error_handling"] = (
+                self.error_handling.value
+                if hasattr(self.error_handling, "value")
+                else self.error_handling
+            )
         return result
 
 
@@ -1564,13 +2281,25 @@ class ExpiryConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.duration is not None:
-            result["duration"] = self.duration
+            result["duration"] = (
+                self.duration.value
+                if hasattr(self.duration, "value")
+                else self.duration
+            )
         if self.field_name is not None:
-            result["field_name"] = self.field_name
+            result["field_name"] = (
+                self.field_name.value
+                if hasattr(self.field_name, "value")
+                else self.field_name
+            )
         if self.refresh_token_duration is not None:
-            result["refresh_token_duration"] = self.refresh_token_duration
+            result["refresh_token_duration"] = (
+                self.refresh_token_duration.value
+                if hasattr(self.refresh_token_duration, "value")
+                else self.refresh_token_duration
+            )
         return result
 
 
@@ -1588,13 +2317,21 @@ class SegmentOption:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["name"] = self.name
-        result["type"] = self.type
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.parent_id is not None:
-            result["parent_id"] = self.parent_id
-        result["metadata"] = self.metadata
-        result["children"] = self.children
+            result["parent_id"] = (
+                self.parent_id.value
+                if hasattr(self.parent_id, "value")
+                else self.parent_id
+            )
+        result["metadata"] = (
+            self.metadata.value if hasattr(self.metadata, "value") else self.metadata
+        )
+        result["children"] = (
+            self.children.value if hasattr(self.children, "value") else self.children
+        )
         return result
 
 
@@ -1635,61 +2372,161 @@ class IntegrationDefinition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["name"] = self.name
-        result["key"] = self.key
-        result["type"] = self.type
-        result["auth_types"] = self.auth_types
-        result["status"] = self.status
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["key"] = self.key.value if hasattr(self.key, "value") else self.key
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["auth_types"] = (
+            self.auth_types.value
+            if hasattr(self.auth_types, "value")
+            else self.auth_types
+        )
+        result["status"] = (
+            self.status.value if hasattr(self.status, "value") else self.status
+        )
         if self.description is not None:
-            result["description"] = self.description
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
         if self.provider_name is not None:
-            result["provider_name"] = self.provider_name
+            result["provider_name"] = (
+                self.provider_name.value
+                if hasattr(self.provider_name, "value")
+                else self.provider_name
+            )
         if self.documentation_url is not None:
-            result["documentation_url"] = self.documentation_url
+            result["documentation_url"] = (
+                self.documentation_url.value
+                if hasattr(self.documentation_url, "value")
+                else self.documentation_url
+            )
         if self.openapi_documentation_url is not None:
-            result["openapi_documentation_url"] = self.openapi_documentation_url
+            result["openapi_documentation_url"] = (
+                self.openapi_documentation_url.value
+                if hasattr(self.openapi_documentation_url, "value")
+                else self.openapi_documentation_url
+            )
         if self.llms_txt_url is not None:
-            result["llms_txt_url"] = self.llms_txt_url
+            result["llms_txt_url"] = (
+                self.llms_txt_url.value
+                if hasattr(self.llms_txt_url, "value")
+                else self.llms_txt_url
+            )
         if self.healthcheck_url is not None:
-            result["healthcheck_url"] = self.healthcheck_url
+            result["healthcheck_url"] = (
+                self.healthcheck_url.value
+                if hasattr(self.healthcheck_url, "value")
+                else self.healthcheck_url
+            )
         if self.auth_url is not None:
-            result["auth_url"] = self.auth_url
+            result["auth_url"] = (
+                self.auth_url.value
+                if hasattr(self.auth_url, "value")
+                else self.auth_url
+            )
         if self.token_url is not None:
-            result["token_url"] = self.token_url
+            result["token_url"] = (
+                self.token_url.value
+                if hasattr(self.token_url, "value")
+                else self.token_url
+            )
         if self.client_id is not None:
-            result["client_id"] = self.client_id
+            result["client_id"] = (
+                self.client_id.value
+                if hasattr(self.client_id, "value")
+                else self.client_id
+            )
         if self.client_secret is not None:
-            result["client_secret"] = self.client_secret
+            result["client_secret"] = (
+                self.client_secret.value
+                if hasattr(self.client_secret, "value")
+                else self.client_secret
+            )
         if self.available_scopes is not None:
-            result["available_scopes"] = self.available_scopes
+            result["available_scopes"] = (
+                self.available_scopes.value
+                if hasattr(self.available_scopes, "value")
+                else self.available_scopes
+            )
         if self.optional_scopes is not None:
-            result["optional_scopes"] = self.optional_scopes
+            result["optional_scopes"] = (
+                self.optional_scopes.value
+                if hasattr(self.optional_scopes, "value")
+                else self.optional_scopes
+            )
         if self.scope_separator is not None:
-            result["scope_separator"] = self.scope_separator
+            result["scope_separator"] = (
+                self.scope_separator.value
+                if hasattr(self.scope_separator, "value")
+                else self.scope_separator
+            )
         if self.api_version is not None:
-            result["api_version"] = self.api_version
+            result["api_version"] = (
+                self.api_version.value
+                if hasattr(self.api_version, "value")
+                else self.api_version
+            )
         if self.api_version_description is not None:
-            result["api_version_description"] = self.api_version_description
+            result["api_version_description"] = (
+                self.api_version_description.value
+                if hasattr(self.api_version_description, "value")
+                else self.api_version_description
+            )
         if self.credential_schema is not None:
-            result["credential_schema"] = self.credential_schema
+            result["credential_schema"] = (
+                self.credential_schema.value
+                if hasattr(self.credential_schema, "value")
+                else self.credential_schema
+            )
         if self.ui_config is not None:
-            result["ui_config"] = self.ui_config
+            result["ui_config"] = (
+                self.ui_config.value
+                if hasattr(self.ui_config, "value")
+                else self.ui_config
+            )
         if self.codegen_details is not None:
-            result["codegen_details"] = self.codegen_details
+            result["codegen_details"] = (
+                self.codegen_details.value
+                if hasattr(self.codegen_details, "value")
+                else self.codegen_details
+            )
         if self.analysis_details is not None:
-            result["analysis_details"] = self.analysis_details
+            result["analysis_details"] = (
+                self.analysis_details.value
+                if hasattr(self.analysis_details, "value")
+                else self.analysis_details
+            )
         if self.segment_config is not None:
-            result["segment_config"] = self.segment_config
+            result["segment_config"] = (
+                self.segment_config.value
+                if hasattr(self.segment_config, "value")
+                else self.segment_config
+            )
         if self.dataset_resource_discovery_config is not None:
             result["dataset_resource_discovery_config"] = (
-                self.dataset_resource_discovery_config
+                self.dataset_resource_discovery_config.value
+                if hasattr(self.dataset_resource_discovery_config, "value")
+                else self.dataset_resource_discovery_config
             )
         if self.expiry_config is not None:
-            result["expiry_config"] = self.expiry_config
+            result["expiry_config"] = (
+                self.expiry_config.value
+                if hasattr(self.expiry_config, "value")
+                else self.expiry_config
+            )
         if self.provider_credentials is not None:
-            result["provider_credentials"] = self.provider_credentials
+            result["provider_credentials"] = (
+                self.provider_credentials.value
+                if hasattr(self.provider_credentials, "value")
+                else self.provider_credentials
+            )
         if self.default_resource_attach_type is not None:
-            result["default_resource_attach_type"] = self.default_resource_attach_type
+            result["default_resource_attach_type"] = (
+                self.default_resource_attach_type.value
+                if hasattr(self.default_resource_attach_type, "value")
+                else self.default_resource_attach_type
+            )
         return result
 
 
@@ -1704,10 +2541,20 @@ class IntegrationConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["definition"] = self.definition
-        result["source"] = self.source
+        result["definition"] = (
+            self.definition.value
+            if hasattr(self.definition, "value")
+            else self.definition
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         if self.file_path is not None:
-            result["file_path"] = self.file_path
+            result["file_path"] = (
+                self.file_path.value
+                if hasattr(self.file_path, "value")
+                else self.file_path
+            )
         return result
 
 
@@ -1722,10 +2569,18 @@ class PythonIntegrationInstance:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["config"] = self.config
-        result["credentials"] = self.credentials
+        result["config"] = (
+            self.config.value if hasattr(self.config, "value") else self.config
+        )
+        result["credentials"] = (
+            self.credentials.value
+            if hasattr(self.credentials, "value")
+            else self.credentials
+        )
         if self.methods is not None:
-            result["methods"] = self.methods
+            result["methods"] = (
+                self.methods.value if hasattr(self.methods, "value") else self.methods
+            )
         return result
 
 
@@ -1741,11 +2596,23 @@ class IntegrationDiscovery:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["config"] = self.config
+        result["config"] = (
+            self.config.value if hasattr(self.config, "value") else self.config
+        )
         if self.instance is not None:
-            result["instance"] = self.instance
-        result["file_path"] = self.file_path
-        result["source_code"] = self.source_code
+            result["instance"] = (
+                self.instance.value
+                if hasattr(self.instance, "value")
+                else self.instance
+            )
+        result["file_path"] = (
+            self.file_path.value if hasattr(self.file_path, "value") else self.file_path
+        )
+        result["source_code"] = (
+            self.source_code.value
+            if hasattr(self.source_code, "value")
+            else self.source_code
+        )
         return result
 
 
@@ -1759,8 +2626,14 @@ class UpsertIntegrationRequest:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integration"] = self.integration
-        result["source"] = self.source
+        result["integration"] = (
+            self.integration.value
+            if hasattr(self.integration, "value")
+            else self.integration
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         return result
 
 
@@ -1774,8 +2647,14 @@ class UpsertIntegrationResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integration_id"] = self.integration_id
-        result["status"] = self.status
+        result["integration_id"] = (
+            self.integration_id.value
+            if hasattr(self.integration_id, "value")
+            else self.integration_id
+        )
+        result["status"] = (
+            self.status.value if hasattr(self.status, "value") else self.status
+        )
         return result
 
 
@@ -1788,7 +2667,11 @@ class ListIntegrationsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integrations"] = self.integrations
+        result["integrations"] = (
+            self.integrations.value
+            if hasattr(self.integrations, "value")
+            else self.integrations
+        )
         return result
 
 
@@ -1801,7 +2684,11 @@ class ExportIntegrationsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integrations"] = self.integrations
+        result["integrations"] = (
+            self.integrations.value
+            if hasattr(self.integrations, "value")
+            else self.integrations
+        )
         return result
 
 
@@ -1834,35 +2721,99 @@ class Memory:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["content"] = self.content
-        result["description"] = self.description
-        result["tags"] = self.tags
-        result["state"] = self.state
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["content"] = (
+            self.content.value if hasattr(self.content, "value") else self.content
+        )
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["tags"] = self.tags.value if hasattr(self.tags, "value") else self.tags
+        result["state"] = (
+            self.state.value if hasattr(self.state, "value") else self.state
+        )
         if self.estimated_stale_at is not None:
-            result["estimated_stale_at"] = self.estimated_stale_at
+            result["estimated_stale_at"] = (
+                self.estimated_stale_at.value
+                if hasattr(self.estimated_stale_at, "value")
+                else self.estimated_stale_at
+            )
         if self.stale_when_text is not None:
-            result["stale_when_text"] = self.stale_when_text
-        result["created_by_entity_type"] = self.created_by_entity_type
-        result["created_by_id"] = self.created_by_id
+            result["stale_when_text"] = (
+                self.stale_when_text.value
+                if hasattr(self.stale_when_text, "value")
+                else self.stale_when_text
+            )
+        result["created_by_entity_type"] = (
+            self.created_by_entity_type.value
+            if hasattr(self.created_by_entity_type, "value")
+            else self.created_by_entity_type
+        )
+        result["created_by_id"] = (
+            self.created_by_id.value
+            if hasattr(self.created_by_id, "value")
+            else self.created_by_id
+        )
         if self.created_from is not None:
-            result["created_from"] = self.created_from
+            result["created_from"] = (
+                self.created_from.value
+                if hasattr(self.created_from, "value")
+                else self.created_from
+            )
         if self.organization_id is not None:
-            result["organization_id"] = self.organization_id
-        result["extra"] = self.extra
-        result["created_at"] = self.created_at
-        result["updated_at"] = self.updated_at
-        result["type"] = self.type
+            result["organization_id"] = (
+                self.organization_id.value
+                if hasattr(self.organization_id, "value")
+                else self.organization_id
+            )
+        result["extra"] = (
+            self.extra.value if hasattr(self.extra, "value") else self.extra
+        )
+        result["created_at"] = (
+            self.created_at.value
+            if hasattr(self.created_at, "value")
+            else self.created_at
+        )
+        result["updated_at"] = (
+            self.updated_at.value
+            if hasattr(self.updated_at, "value")
+            else self.updated_at
+        )
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.dataset_id is not None:
-            result["dataset_id"] = self.dataset_id
+            result["dataset_id"] = (
+                self.dataset_id.value
+                if hasattr(self.dataset_id, "value")
+                else self.dataset_id
+            )
         if self.integration_config_id is not None:
-            result["integration_config_id"] = self.integration_config_id
+            result["integration_config_id"] = (
+                self.integration_config_id.value
+                if hasattr(self.integration_config_id, "value")
+                else self.integration_config_id
+            )
         if self.user_id is not None:
-            result["user_id"] = self.user_id
+            result["user_id"] = (
+                self.user_id.value if hasattr(self.user_id, "value") else self.user_id
+            )
         if self.thread_id is not None:
-            result["thread_id"] = self.thread_id
-        result["current_version"] = self.current_version
-        result["approval_status"] = self.approval_status
+            result["thread_id"] = (
+                self.thread_id.value
+                if hasattr(self.thread_id, "value")
+                else self.thread_id
+            )
+        result["current_version"] = (
+            self.current_version.value
+            if hasattr(self.current_version, "value")
+            else self.current_version
+        )
+        result["approval_status"] = (
+            self.approval_status.value
+            if hasattr(self.approval_status, "value")
+            else self.approval_status
+        )
         return result
 
 
@@ -1878,10 +2829,20 @@ class ResourceAnalysis:
         """Convert to dict format expected by backend."""
         result = {}
         if self.summary is not None:
-            result["summary"] = self.summary
+            result["summary"] = (
+                self.summary.value if hasattr(self.summary, "value") else self.summary
+            )
         if self.last_analyzed is not None:
-            result["last_analyzed"] = self.last_analyzed
-        result["entity_key"] = self.entity_key
+            result["last_analyzed"] = (
+                self.last_analyzed.value
+                if hasattr(self.last_analyzed, "value")
+                else self.last_analyzed
+            )
+        result["entity_key"] = (
+            self.entity_key.value
+            if hasattr(self.entity_key, "value")
+            else self.entity_key
+        )
         return result
 
 
@@ -1909,24 +2870,62 @@ class Resource:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["key"] = self.key
-        result["name"] = self.name
-        result["type"] = self.type
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["key"] = self.key.value if hasattr(self.key, "value") else self.key
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.description is not None:
-            result["description"] = self.description
-        result["use_cases"] = self.use_cases
-        result["tags"] = self.tags
-        result["created_at"] = self.created_at
-        result["updated_at"] = self.updated_at
-        result["integration_config_id"] = self.integration_config_id
-        result["state"] = self.state
-        result["attach_type"] = self.attach_type
-        result["dataset_id"] = self.dataset_id
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
+        result["use_cases"] = (
+            self.use_cases.value if hasattr(self.use_cases, "value") else self.use_cases
+        )
+        result["tags"] = self.tags.value if hasattr(self.tags, "value") else self.tags
+        result["created_at"] = (
+            self.created_at.value
+            if hasattr(self.created_at, "value")
+            else self.created_at
+        )
+        result["updated_at"] = (
+            self.updated_at.value
+            if hasattr(self.updated_at, "value")
+            else self.updated_at
+        )
+        result["integration_config_id"] = (
+            self.integration_config_id.value
+            if hasattr(self.integration_config_id, "value")
+            else self.integration_config_id
+        )
+        result["state"] = (
+            self.state.value if hasattr(self.state, "value") else self.state
+        )
+        result["attach_type"] = (
+            self.attach_type.value
+            if hasattr(self.attach_type, "value")
+            else self.attach_type
+        )
+        result["dataset_id"] = (
+            self.dataset_id.value
+            if hasattr(self.dataset_id, "value")
+            else self.dataset_id
+        )
         if self.instructions is not None:
-            result["instructions"] = self.instructions
-        result["analyses"] = self.analyses
-        result["related_resources"] = self.related_resources
+            result["instructions"] = (
+                self.instructions.value
+                if hasattr(self.instructions, "value")
+                else self.instructions
+            )
+        result["analyses"] = (
+            self.analyses.value if hasattr(self.analyses, "value") else self.analyses
+        )
+        result["related_resources"] = (
+            self.related_resources.value
+            if hasattr(self.related_resources, "value")
+            else self.related_resources
+        )
         return result
 
 
@@ -1941,8 +2940,8 @@ class UIConfigIcon:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["set"] = self.set
-        result["name"] = self.name
+        result["set"] = self.set.value if hasattr(self.set, "value") else self.set
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
         return result
 
 
@@ -1957,9 +2956,21 @@ class UIConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["brand_logo_icon"] = self.brand_logo_icon
-        result["brand_color"] = self.brand_color
-        result["button_style"] = self.button_style
+        result["brand_logo_icon"] = (
+            self.brand_logo_icon.value
+            if hasattr(self.brand_logo_icon, "value")
+            else self.brand_logo_icon
+        )
+        result["brand_color"] = (
+            self.brand_color.value
+            if hasattr(self.brand_color, "value")
+            else self.brand_color
+        )
+        result["button_style"] = (
+            self.button_style.value
+            if hasattr(self.button_style, "value")
+            else self.button_style
+        )
         return result
 
 
@@ -1974,9 +2985,17 @@ class ErrorHandlingConfig:
         """Convert to dict format expected by backend."""
         result = {}
         if self.ignore_errors is not None:
-            result["ignore_errors"] = self.ignore_errors
+            result["ignore_errors"] = (
+                self.ignore_errors.value
+                if hasattr(self.ignore_errors, "value")
+                else self.ignore_errors
+            )
         if self.error_path is not None:
-            result["error_path"] = self.error_path
+            result["error_path"] = (
+                self.error_path.value
+                if hasattr(self.error_path, "value")
+                else self.error_path
+            )
         return result
 
 
@@ -1999,25 +3018,55 @@ class SegmentLevel:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["name"] = self.name
-        result["type"] = self.type
-        result["selectable"] = self.selectable
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["selectable"] = (
+            self.selectable.value
+            if hasattr(self.selectable, "value")
+            else self.selectable
+        )
         if self.url_template is not None:
-            result["url_template"] = self.url_template
+            result["url_template"] = (
+                self.url_template.value
+                if hasattr(self.url_template, "value")
+                else self.url_template
+            )
         if self.method is not None:
-            result["method"] = self.method
+            result["method"] = (
+                self.method.value if hasattr(self.method, "value") else self.method
+            )
         if self.body is not None:
-            result["body"] = self.body
+            result["body"] = (
+                self.body.value if hasattr(self.body, "value") else self.body
+            )
         if self.id_path is not None:
-            result["id_path"] = self.id_path
+            result["id_path"] = (
+                self.id_path.value if hasattr(self.id_path, "value") else self.id_path
+            )
         if self.id_regex is not None:
-            result["id_regex"] = self.id_regex
+            result["id_regex"] = (
+                self.id_regex.value
+                if hasattr(self.id_regex, "value")
+                else self.id_regex
+            )
         if self.name_path is not None:
-            result["name_path"] = self.name_path
+            result["name_path"] = (
+                self.name_path.value
+                if hasattr(self.name_path, "value")
+                else self.name_path
+            )
         if self.parent_key is not None:
-            result["parent_key"] = self.parent_key
+            result["parent_key"] = (
+                self.parent_key.value
+                if hasattr(self.parent_key, "value")
+                else self.parent_key
+            )
         if self.required_credentials is not None:
-            result["required_credentials"] = self.required_credentials
+            result["required_credentials"] = (
+                self.required_credentials.value
+                if hasattr(self.required_credentials, "value")
+                else self.required_credentials
+            )
         return result
 
 
@@ -2037,18 +3086,48 @@ class SegmentConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["selection_type"] = self.selection_type
+        result["selection_type"] = (
+            self.selection_type.value
+            if hasattr(self.selection_type, "value")
+            else self.selection_type
+        )
         if self.min_selections is not None:
-            result["min_selections"] = self.min_selections
+            result["min_selections"] = (
+                self.min_selections.value
+                if hasattr(self.min_selections, "value")
+                else self.min_selections
+            )
         if self.max_selections is not None:
-            result["max_selections"] = self.max_selections
-        result["description"] = self.description
-        result["hierarchical"] = self.hierarchical
+            result["max_selections"] = (
+                self.max_selections.value
+                if hasattr(self.max_selections, "value")
+                else self.max_selections
+            )
+        result["description"] = (
+            self.description.value
+            if hasattr(self.description, "value")
+            else self.description
+        )
+        result["hierarchical"] = (
+            self.hierarchical.value
+            if hasattr(self.hierarchical, "value")
+            else self.hierarchical
+        )
         if self.base_url is not None:
-            result["base_url"] = self.base_url
-        result["levels"] = self.levels
+            result["base_url"] = (
+                self.base_url.value
+                if hasattr(self.base_url, "value")
+                else self.base_url
+            )
+        result["levels"] = (
+            self.levels.value if hasattr(self.levels, "value") else self.levels
+        )
         if self.error_handling is not None:
-            result["error_handling"] = self.error_handling
+            result["error_handling"] = (
+                self.error_handling.value
+                if hasattr(self.error_handling, "value")
+                else self.error_handling
+            )
         return result
 
 
@@ -2067,16 +3146,32 @@ class ResourceTypeConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
-        result["url_template"] = self.url_template
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["url_template"] = (
+            self.url_template.value
+            if hasattr(self.url_template, "value")
+            else self.url_template
+        )
         if self.method is not None:
-            result["method"] = self.method
+            result["method"] = (
+                self.method.value if hasattr(self.method, "value") else self.method
+            )
         if self.body is not None:
-            result["body"] = self.body
-        result["id_path"] = self.id_path
-        result["name_path"] = self.name_path
+            result["body"] = (
+                self.body.value if hasattr(self.body, "value") else self.body
+            )
+        result["id_path"] = (
+            self.id_path.value if hasattr(self.id_path, "value") else self.id_path
+        )
+        result["name_path"] = (
+            self.name_path.value if hasattr(self.name_path, "value") else self.name_path
+        )
         if self.description_path is not None:
-            result["description_path"] = self.description_path
+            result["description_path"] = (
+                self.description_path.value
+                if hasattr(self.description_path, "value")
+                else self.description_path
+            )
         return result
 
 
@@ -2098,25 +3193,65 @@ class DatasetResourceDiscoveryConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["min_resources_required"] = self.min_resources_required
+        result["min_resources_required"] = (
+            self.min_resources_required.value
+            if hasattr(self.min_resources_required, "value")
+            else self.min_resources_required
+        )
         if self.table_query is not None:
-            result["table_query"] = self.table_query
+            result["table_query"] = (
+                self.table_query.value
+                if hasattr(self.table_query, "value")
+                else self.table_query
+            )
         if self.relationship_query is not None:
-            result["relationship_query"] = self.relationship_query
+            result["relationship_query"] = (
+                self.relationship_query.value
+                if hasattr(self.relationship_query, "value")
+                else self.relationship_query
+            )
         if self.index_query is not None:
-            result["index_query"] = self.index_query
+            result["index_query"] = (
+                self.index_query.value
+                if hasattr(self.index_query, "value")
+                else self.index_query
+            )
         if self.constraint_query is not None:
-            result["constraint_query"] = self.constraint_query
+            result["constraint_query"] = (
+                self.constraint_query.value
+                if hasattr(self.constraint_query, "value")
+                else self.constraint_query
+            )
         if self.statistics_query is not None:
-            result["statistics_query"] = self.statistics_query
+            result["statistics_query"] = (
+                self.statistics_query.value
+                if hasattr(self.statistics_query, "value")
+                else self.statistics_query
+            )
         if self.size_query is not None:
-            result["size_query"] = self.size_query
+            result["size_query"] = (
+                self.size_query.value
+                if hasattr(self.size_query, "value")
+                else self.size_query
+            )
         if self.base_url is not None:
-            result["base_url"] = self.base_url
+            result["base_url"] = (
+                self.base_url.value
+                if hasattr(self.base_url, "value")
+                else self.base_url
+            )
         if self.resource_types is not None:
-            result["resource_types"] = self.resource_types
+            result["resource_types"] = (
+                self.resource_types.value
+                if hasattr(self.resource_types, "value")
+                else self.resource_types
+            )
         if self.error_handling is not None:
-            result["error_handling"] = self.error_handling
+            result["error_handling"] = (
+                self.error_handling.value
+                if hasattr(self.error_handling, "value")
+                else self.error_handling
+            )
         return result
 
 
@@ -2132,13 +3267,25 @@ class ExpiryConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["type"] = self.type
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.duration is not None:
-            result["duration"] = self.duration
+            result["duration"] = (
+                self.duration.value
+                if hasattr(self.duration, "value")
+                else self.duration
+            )
         if self.field_name is not None:
-            result["field_name"] = self.field_name
+            result["field_name"] = (
+                self.field_name.value
+                if hasattr(self.field_name, "value")
+                else self.field_name
+            )
         if self.refresh_token_duration is not None:
-            result["refresh_token_duration"] = self.refresh_token_duration
+            result["refresh_token_duration"] = (
+                self.refresh_token_duration.value
+                if hasattr(self.refresh_token_duration, "value")
+                else self.refresh_token_duration
+            )
         return result
 
 
@@ -2156,13 +3303,21 @@ class SegmentOption:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["id"] = self.id
-        result["name"] = self.name
-        result["type"] = self.type
+        result["id"] = self.id.value if hasattr(self.id, "value") else self.id
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
         if self.parent_id is not None:
-            result["parent_id"] = self.parent_id
-        result["metadata"] = self.metadata
-        result["children"] = self.children
+            result["parent_id"] = (
+                self.parent_id.value
+                if hasattr(self.parent_id, "value")
+                else self.parent_id
+            )
+        result["metadata"] = (
+            self.metadata.value if hasattr(self.metadata, "value") else self.metadata
+        )
+        result["children"] = (
+            self.children.value if hasattr(self.children, "value") else self.children
+        )
         return result
 
 
@@ -2203,61 +3358,161 @@ class IntegrationDefinition:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["name"] = self.name
-        result["key"] = self.key
-        result["type"] = self.type
-        result["auth_types"] = self.auth_types
-        result["status"] = self.status
+        result["name"] = self.name.value if hasattr(self.name, "value") else self.name
+        result["key"] = self.key.value if hasattr(self.key, "value") else self.key
+        result["type"] = self.type.value if hasattr(self.type, "value") else self.type
+        result["auth_types"] = (
+            self.auth_types.value
+            if hasattr(self.auth_types, "value")
+            else self.auth_types
+        )
+        result["status"] = (
+            self.status.value if hasattr(self.status, "value") else self.status
+        )
         if self.description is not None:
-            result["description"] = self.description
+            result["description"] = (
+                self.description.value
+                if hasattr(self.description, "value")
+                else self.description
+            )
         if self.provider_name is not None:
-            result["provider_name"] = self.provider_name
+            result["provider_name"] = (
+                self.provider_name.value
+                if hasattr(self.provider_name, "value")
+                else self.provider_name
+            )
         if self.documentation_url is not None:
-            result["documentation_url"] = self.documentation_url
+            result["documentation_url"] = (
+                self.documentation_url.value
+                if hasattr(self.documentation_url, "value")
+                else self.documentation_url
+            )
         if self.openapi_documentation_url is not None:
-            result["openapi_documentation_url"] = self.openapi_documentation_url
+            result["openapi_documentation_url"] = (
+                self.openapi_documentation_url.value
+                if hasattr(self.openapi_documentation_url, "value")
+                else self.openapi_documentation_url
+            )
         if self.llms_txt_url is not None:
-            result["llms_txt_url"] = self.llms_txt_url
+            result["llms_txt_url"] = (
+                self.llms_txt_url.value
+                if hasattr(self.llms_txt_url, "value")
+                else self.llms_txt_url
+            )
         if self.healthcheck_url is not None:
-            result["healthcheck_url"] = self.healthcheck_url
+            result["healthcheck_url"] = (
+                self.healthcheck_url.value
+                if hasattr(self.healthcheck_url, "value")
+                else self.healthcheck_url
+            )
         if self.auth_url is not None:
-            result["auth_url"] = self.auth_url
+            result["auth_url"] = (
+                self.auth_url.value
+                if hasattr(self.auth_url, "value")
+                else self.auth_url
+            )
         if self.token_url is not None:
-            result["token_url"] = self.token_url
+            result["token_url"] = (
+                self.token_url.value
+                if hasattr(self.token_url, "value")
+                else self.token_url
+            )
         if self.client_id is not None:
-            result["client_id"] = self.client_id
+            result["client_id"] = (
+                self.client_id.value
+                if hasattr(self.client_id, "value")
+                else self.client_id
+            )
         if self.client_secret is not None:
-            result["client_secret"] = self.client_secret
+            result["client_secret"] = (
+                self.client_secret.value
+                if hasattr(self.client_secret, "value")
+                else self.client_secret
+            )
         if self.available_scopes is not None:
-            result["available_scopes"] = self.available_scopes
+            result["available_scopes"] = (
+                self.available_scopes.value
+                if hasattr(self.available_scopes, "value")
+                else self.available_scopes
+            )
         if self.optional_scopes is not None:
-            result["optional_scopes"] = self.optional_scopes
+            result["optional_scopes"] = (
+                self.optional_scopes.value
+                if hasattr(self.optional_scopes, "value")
+                else self.optional_scopes
+            )
         if self.scope_separator is not None:
-            result["scope_separator"] = self.scope_separator
+            result["scope_separator"] = (
+                self.scope_separator.value
+                if hasattr(self.scope_separator, "value")
+                else self.scope_separator
+            )
         if self.api_version is not None:
-            result["api_version"] = self.api_version
+            result["api_version"] = (
+                self.api_version.value
+                if hasattr(self.api_version, "value")
+                else self.api_version
+            )
         if self.api_version_description is not None:
-            result["api_version_description"] = self.api_version_description
+            result["api_version_description"] = (
+                self.api_version_description.value
+                if hasattr(self.api_version_description, "value")
+                else self.api_version_description
+            )
         if self.credential_schema is not None:
-            result["credential_schema"] = self.credential_schema
+            result["credential_schema"] = (
+                self.credential_schema.value
+                if hasattr(self.credential_schema, "value")
+                else self.credential_schema
+            )
         if self.ui_config is not None:
-            result["ui_config"] = self.ui_config
+            result["ui_config"] = (
+                self.ui_config.value
+                if hasattr(self.ui_config, "value")
+                else self.ui_config
+            )
         if self.codegen_details is not None:
-            result["codegen_details"] = self.codegen_details
+            result["codegen_details"] = (
+                self.codegen_details.value
+                if hasattr(self.codegen_details, "value")
+                else self.codegen_details
+            )
         if self.analysis_details is not None:
-            result["analysis_details"] = self.analysis_details
+            result["analysis_details"] = (
+                self.analysis_details.value
+                if hasattr(self.analysis_details, "value")
+                else self.analysis_details
+            )
         if self.segment_config is not None:
-            result["segment_config"] = self.segment_config
+            result["segment_config"] = (
+                self.segment_config.value
+                if hasattr(self.segment_config, "value")
+                else self.segment_config
+            )
         if self.dataset_resource_discovery_config is not None:
             result["dataset_resource_discovery_config"] = (
-                self.dataset_resource_discovery_config
+                self.dataset_resource_discovery_config.value
+                if hasattr(self.dataset_resource_discovery_config, "value")
+                else self.dataset_resource_discovery_config
             )
         if self.expiry_config is not None:
-            result["expiry_config"] = self.expiry_config
+            result["expiry_config"] = (
+                self.expiry_config.value
+                if hasattr(self.expiry_config, "value")
+                else self.expiry_config
+            )
         if self.provider_credentials is not None:
-            result["provider_credentials"] = self.provider_credentials
+            result["provider_credentials"] = (
+                self.provider_credentials.value
+                if hasattr(self.provider_credentials, "value")
+                else self.provider_credentials
+            )
         if self.default_resource_attach_type is not None:
-            result["default_resource_attach_type"] = self.default_resource_attach_type
+            result["default_resource_attach_type"] = (
+                self.default_resource_attach_type.value
+                if hasattr(self.default_resource_attach_type, "value")
+                else self.default_resource_attach_type
+            )
         return result
 
 
@@ -2272,10 +3527,20 @@ class IntegrationConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["definition"] = self.definition
-        result["source"] = self.source
+        result["definition"] = (
+            self.definition.value
+            if hasattr(self.definition, "value")
+            else self.definition
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         if self.file_path is not None:
-            result["file_path"] = self.file_path
+            result["file_path"] = (
+                self.file_path.value
+                if hasattr(self.file_path, "value")
+                else self.file_path
+            )
         return result
 
 
@@ -2290,10 +3555,18 @@ class PythonIntegrationInstance:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["config"] = self.config
-        result["credentials"] = self.credentials
+        result["config"] = (
+            self.config.value if hasattr(self.config, "value") else self.config
+        )
+        result["credentials"] = (
+            self.credentials.value
+            if hasattr(self.credentials, "value")
+            else self.credentials
+        )
         if self.methods is not None:
-            result["methods"] = self.methods
+            result["methods"] = (
+                self.methods.value if hasattr(self.methods, "value") else self.methods
+            )
         return result
 
 
@@ -2309,11 +3582,23 @@ class IntegrationDiscovery:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["config"] = self.config
+        result["config"] = (
+            self.config.value if hasattr(self.config, "value") else self.config
+        )
         if self.instance is not None:
-            result["instance"] = self.instance
-        result["file_path"] = self.file_path
-        result["source_code"] = self.source_code
+            result["instance"] = (
+                self.instance.value
+                if hasattr(self.instance, "value")
+                else self.instance
+            )
+        result["file_path"] = (
+            self.file_path.value if hasattr(self.file_path, "value") else self.file_path
+        )
+        result["source_code"] = (
+            self.source_code.value
+            if hasattr(self.source_code, "value")
+            else self.source_code
+        )
         return result
 
 
@@ -2327,8 +3612,14 @@ class UpsertIntegrationRequest:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integration"] = self.integration
-        result["source"] = self.source
+        result["integration"] = (
+            self.integration.value
+            if hasattr(self.integration, "value")
+            else self.integration
+        )
+        result["source"] = (
+            self.source.value if hasattr(self.source, "value") else self.source
+        )
         return result
 
 
@@ -2342,8 +3633,14 @@ class UpsertIntegrationResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integration_id"] = self.integration_id
-        result["status"] = self.status
+        result["integration_id"] = (
+            self.integration_id.value
+            if hasattr(self.integration_id, "value")
+            else self.integration_id
+        )
+        result["status"] = (
+            self.status.value if hasattr(self.status, "value") else self.status
+        )
         return result
 
 
@@ -2356,7 +3653,11 @@ class ListIntegrationsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integrations"] = self.integrations
+        result["integrations"] = (
+            self.integrations.value
+            if hasattr(self.integrations, "value")
+            else self.integrations
+        )
         return result
 
 
@@ -2369,7 +3670,11 @@ class ExportIntegrationsResponse:
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result = {}
-        result["integrations"] = self.integrations
+        result["integrations"] = (
+            self.integrations.value
+            if hasattr(self.integrations, "value")
+            else self.integrations
+        )
         return result
 
 
@@ -2386,7 +3691,6 @@ __all__ = [
     "APIStepWithHandlers",
     "APITool",
     "ActionDefinition",
-    "AgentDiscovery",
     "AnalysisDetails",
     "AuthType",
     "Bot",
@@ -2401,7 +3705,6 @@ __all__ = [
     "DatasetType",
     "Error",
     "ErrorHandlingConfig",
-    "ExecutionModeConfig",
     "ExecutionModeType",
     "ExpiryConfig",
     "ExpiryType",
@@ -2441,7 +3744,6 @@ __all__ = [
     "ResourceType",
     "ResourceTypeConfig",
     "Result",
-    "ResultHandler",
     "ResultSchema",
     "SegmentConfig",
     "SegmentLevel",
@@ -2450,7 +3752,6 @@ __all__ = [
     "SensitivityLevel",
     "ServiceDefinition",
     "Status",
-    "StepWithHandlers",
     "StepsResponse",
     "SystemParameters",
     "TempCondition",