daytona_toolbox_api_client 0.103.0rc2__py3-none-any.whl → 0.108.0rc1__py3-none-any.whl

daytona_toolbox_api_client/api/process_api.py

@@ -17,12 +17,17 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
 from pydantic import Field, StrictBool, StrictStr
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 from typing_extensions import Annotated
 from daytona_toolbox_api_client.models.command import Command
 from daytona_toolbox_api_client.models.create_session_request import CreateSessionRequest
 from daytona_toolbox_api_client.models.execute_request import ExecuteRequest
 from daytona_toolbox_api_client.models.execute_response import ExecuteResponse
+from daytona_toolbox_api_client.models.pty_create_request import PtyCreateRequest
+from daytona_toolbox_api_client.models.pty_create_response import PtyCreateResponse
+from daytona_toolbox_api_client.models.pty_list_response import PtyListResponse
+from daytona_toolbox_api_client.models.pty_resize_request import PtyResizeRequest
+from daytona_toolbox_api_client.models.pty_session_info import PtySessionInfo
 from daytona_toolbox_api_client.models.session import Session
 from daytona_toolbox_api_client.models.session_execute_request import SessionExecuteRequest
 from daytona_toolbox_api_client.models.session_execute_response import SessionExecuteResponse
@@ -46,9 +51,9 @@ class ProcessApi:
 
 
     @validate_call
-    def create_session(
+    def connect_pty_session(
         self,
-        request: Annotated[CreateSessionRequest, Field(description="Session creation request")],
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -62,12 +67,12 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """Create a new session
+        """Connect to PTY session via WebSocket
 
-        Create a new shell session for command execution
+        Establish a WebSocket connection to interact with a pseudo-terminal session
 
-        :param request: Session creation request (required)
-        :type request: CreateSessionRequest
+        :param session_id: PTY session ID (required)
+        :type session_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -90,8 +95,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._create_session_serialize(
-            request=request,
+        _param = self._connect_pty_session_serialize(
+            session_id=session_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -99,7 +104,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': None,
+            '101': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -113,9 +118,9 @@ class ProcessApi:
 
 
     @validate_call
-    def create_session_with_http_info(
+    def connect_pty_session_with_http_info(
         self,
-        request: Annotated[CreateSessionRequest, Field(description="Session creation request")],
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -129,12 +134,12 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """Create a new session
+        """Connect to PTY session via WebSocket
 
-        Create a new shell session for command execution
+        Establish a WebSocket connection to interact with a pseudo-terminal session
 
-        :param request: Session creation request (required)
-        :type request: CreateSessionRequest
+        :param session_id: PTY session ID (required)
+        :type session_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -157,8 +162,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._create_session_serialize(
-            request=request,
+        _param = self._connect_pty_session_serialize(
+            session_id=session_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -166,7 +171,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': None,
+            '101': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -180,9 +185,9 @@ class ProcessApi:
 
 
     @validate_call
-    def create_session_without_preload_content(
+    def connect_pty_session_without_preload_content(
         self,
-        request: Annotated[CreateSessionRequest, Field(description="Session creation request")],
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -196,12 +201,12 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Create a new session
+        """Connect to PTY session via WebSocket
 
-        Create a new shell session for command execution
+        Establish a WebSocket connection to interact with a pseudo-terminal session
 
-        :param request: Session creation request (required)
-        :type request: CreateSessionRequest
+        :param session_id: PTY session ID (required)
+        :type session_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -224,8 +229,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._create_session_serialize(
-            request=request,
+        _param = self._connect_pty_session_serialize(
+            session_id=session_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -233,7 +238,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '201': None,
+            '101': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -242,9 +247,9 @@ class ProcessApi:
         return response_data.response
 
 
-    def _create_session_serialize(
+    def _connect_pty_session_serialize(
         self,
-        request,
+        session_id,
         _request_auth,
         _content_type,
         _headers,
@@ -266,36 +271,23 @@ class ProcessApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if request is not None:
-            _body_params = request
 
 
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/process/session',
+            method='GET',
+            resource_path='/process/pty/{sessionId}/connect',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -312,9 +304,9 @@ class ProcessApi:
 
 
     @validate_call
-    def delete_session(
+    def create_pty_session(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        request: Annotated[PtyCreateRequest, Field(description="PTY session creation request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -327,13 +319,13 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Delete a session
+    ) -> PtyCreateResponse:
+        """Create a new PTY session
 
-        Delete an existing shell session
+        Create a new pseudo-terminal session with specified configuration
 
-        :param session_id: Session ID (required)
-        :type session_id: str
+        :param request: PTY session creation request (required)
+        :type request: PtyCreateRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -356,8 +348,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._delete_session_serialize(
-            session_id=session_id,
+        _param = self._create_pty_session_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -365,7 +357,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '201': "PtyCreateResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -379,9 +371,9 @@ class ProcessApi:
 
 
     @validate_call
-    def delete_session_with_http_info(
+    def create_pty_session_with_http_info(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        request: Annotated[PtyCreateRequest, Field(description="PTY session creation request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -394,13 +386,13 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Delete a session
+    ) -> ApiResponse[PtyCreateResponse]:
+        """Create a new PTY session
 
-        Delete an existing shell session
+        Create a new pseudo-terminal session with specified configuration
 
-        :param session_id: Session ID (required)
-        :type session_id: str
+        :param request: PTY session creation request (required)
+        :type request: PtyCreateRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -423,8 +415,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._delete_session_serialize(
-            session_id=session_id,
+        _param = self._create_pty_session_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -432,7 +424,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '201': "PtyCreateResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -446,9 +438,9 @@ class ProcessApi:
 
 
     @validate_call
-    def delete_session_without_preload_content(
+    def create_pty_session_without_preload_content(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        request: Annotated[PtyCreateRequest, Field(description="PTY session creation request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -462,12 +454,12 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Delete a session
+        """Create a new PTY session
 
-        Delete an existing shell session
+        Create a new pseudo-terminal session with specified configuration
 
-        :param session_id: Session ID (required)
-        :type session_id: str
+        :param request: PTY session creation request (required)
+        :type request: PtyCreateRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -490,8 +482,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._delete_session_serialize(
-            session_id=session_id,
+        _param = self._create_pty_session_serialize(
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -499,7 +491,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '201': "PtyCreateResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -508,9 +500,9 @@ class ProcessApi:
         return response_data.response
 
 
-    def _delete_session_serialize(
+    def _create_pty_session_serialize(
         self,
-        session_id,
+        request,
         _request_auth,
         _content_type,
         _headers,
@@ -532,23 +524,43 @@ class ProcessApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if session_id is not None:
-            _path_params['sessionId'] = session_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if request is not None:
+            _body_params = request
 
 
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
         ]
 
         return self.api_client.param_serialize(
-            method='DELETE',
-            resource_path='/process/session/{sessionId}',
+            method='POST',
+            resource_path='/process/pty',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -565,9 +577,9 @@ class ProcessApi:
 
 
     @validate_call
-    def execute_command(
+    def create_session(
         self,
-        request: Annotated[ExecuteRequest, Field(description="Command execution request")],
+        request: Annotated[CreateSessionRequest, Field(description="Session creation request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -580,13 +592,13 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ExecuteResponse:
-        """Execute a command
+    ) -> None:
+        """Create a new session
 
-        Execute a shell command and return the output and exit code
+        Create a new shell session for command execution
 
-        :param request: Command execution request (required)
-        :type request: ExecuteRequest
+        :param request: Session creation request (required)
+        :type request: CreateSessionRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -609,7 +621,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._execute_command_serialize(
+        _param = self._create_session_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -618,7 +630,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ExecuteResponse",
+            '201': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -632,9 +644,9 @@ class ProcessApi:
 
 
     @validate_call
-    def execute_command_with_http_info(
+    def create_session_with_http_info(
         self,
-        request: Annotated[ExecuteRequest, Field(description="Command execution request")],
+        request: Annotated[CreateSessionRequest, Field(description="Session creation request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -647,13 +659,13 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ExecuteResponse]:
-        """Execute a command
+    ) -> ApiResponse[None]:
+        """Create a new session
 
-        Execute a shell command and return the output and exit code
+        Create a new shell session for command execution
 
-        :param request: Command execution request (required)
-        :type request: ExecuteRequest
+        :param request: Session creation request (required)
+        :type request: CreateSessionRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -676,7 +688,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._execute_command_serialize(
+        _param = self._create_session_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -685,7 +697,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ExecuteResponse",
+            '201': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -699,9 +711,9 @@ class ProcessApi:
 
 
     @validate_call
-    def execute_command_without_preload_content(
+    def create_session_without_preload_content(
         self,
-        request: Annotated[ExecuteRequest, Field(description="Command execution request")],
+        request: Annotated[CreateSessionRequest, Field(description="Session creation request")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -715,12 +727,12 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Execute a command
+        """Create a new session
 
-        Execute a shell command and return the output and exit code
+        Create a new shell session for command execution
 
-        :param request: Command execution request (required)
-        :type request: ExecuteRequest
+        :param request: Session creation request (required)
+        :type request: CreateSessionRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -743,7 +755,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._execute_command_serialize(
+        _param = self._create_session_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -752,7 +764,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ExecuteResponse",
+            '201': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -761,7 +773,7 @@ class ProcessApi:
         return response_data.response
 
 
-    def _execute_command_serialize(
+    def _create_session_serialize(
         self,
         request,
         _request_auth,
@@ -793,13 +805,6 @@ class ProcessApi:
             _body_params = request
 
 
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'application/json'
-                ]
-            )
 
         # set the HTTP header `Content-Type`
         if _content_type:
@@ -821,7 +826,7 @@ class ProcessApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/process/execute',
+            resource_path='/process/session',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -838,9 +843,9 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session(
+    def delete_pty_session(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -853,12 +858,12 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> Session:
-        """Get session details
+    ) -> Dict[str, object]:
+        """Delete a PTY session
 
-        Get details of a specific session including its commands
+        Delete a pseudo-terminal session and terminate its process
 
-        :param session_id: Session ID (required)
+        :param session_id: PTY session ID (required)
         :type session_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -882,7 +887,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_serialize(
+        _param = self._delete_pty_session_serialize(
             session_id=session_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -891,7 +896,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Session",
+            '200': "Dict[str, object]",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -905,9 +910,9 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_with_http_info(
+    def delete_pty_session_with_http_info(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -920,12 +925,12 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[Session]:
-        """Get session details
+    ) -> ApiResponse[Dict[str, object]]:
+        """Delete a PTY session
 
-        Get details of a specific session including its commands
+        Delete a pseudo-terminal session and terminate its process
 
-        :param session_id: Session ID (required)
+        :param session_id: PTY session ID (required)
         :type session_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -949,7 +954,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_serialize(
+        _param = self._delete_pty_session_serialize(
             session_id=session_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -958,7 +963,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Session",
+            '200': "Dict[str, object]",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -972,9 +977,9 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_without_preload_content(
+    def delete_pty_session_without_preload_content(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -988,11 +993,11 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get session details
+        """Delete a PTY session
 
-        Get details of a specific session including its commands
+        Delete a pseudo-terminal session and terminate its process
 
-        :param session_id: Session ID (required)
+        :param session_id: PTY session ID (required)
         :type session_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -1016,7 +1021,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_serialize(
+        _param = self._delete_pty_session_serialize(
             session_id=session_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1025,7 +1030,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Session",
+            '200': "Dict[str, object]",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1034,7 +1039,7 @@ class ProcessApi:
         return response_data.response
 
 
-    def _get_session_serialize(
+    def _delete_pty_session_serialize(
         self,
         session_id,
         _request_auth,
@@ -1080,8 +1085,8 @@ class ProcessApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/process/session/{sessionId}',
+            method='DELETE',
+            resource_path='/process/pty/{sessionId}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1098,10 +1103,9 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_command(
+    def delete_session(
         self,
         session_id: Annotated[StrictStr, Field(description="Session ID")],
-        command_id: Annotated[StrictStr, Field(description="Command ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1114,15 +1118,13 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> Command:
-        """Get session command details
+    ) -> None:
+        """Delete a session
 
-        Get details of a specific command within a session
+        Delete an existing shell session
 
         :param session_id: Session ID (required)
         :type session_id: str
-        :param command_id: Command ID (required)
-        :type command_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1145,9 +1147,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_command_serialize(
+        _param = self._delete_session_serialize(
             session_id=session_id,
-            command_id=command_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1155,7 +1156,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Command",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1169,10 +1170,9 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_command_with_http_info(
+    def delete_session_with_http_info(
         self,
         session_id: Annotated[StrictStr, Field(description="Session ID")],
-        command_id: Annotated[StrictStr, Field(description="Command ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1185,15 +1185,13 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[Command]:
-        """Get session command details
+    ) -> ApiResponse[None]:
+        """Delete a session
 
-        Get details of a specific command within a session
+        Delete an existing shell session
 
         :param session_id: Session ID (required)
         :type session_id: str
-        :param command_id: Command ID (required)
-        :type command_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1216,9 +1214,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_command_serialize(
+        _param = self._delete_session_serialize(
             session_id=session_id,
-            command_id=command_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1226,7 +1223,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Command",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1240,10 +1237,9 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_command_without_preload_content(
+    def delete_session_without_preload_content(
         self,
         session_id: Annotated[StrictStr, Field(description="Session ID")],
-        command_id: Annotated[StrictStr, Field(description="Command ID")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1257,14 +1253,12 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get session command details
+        """Delete a session
 
-        Get details of a specific command within a session
+        Delete an existing shell session
 
         :param session_id: Session ID (required)
         :type session_id: str
-        :param command_id: Command ID (required)
-        :type command_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1287,9 +1281,8 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_command_serialize(
+        _param = self._delete_session_serialize(
             session_id=session_id,
-            command_id=command_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1297,7 +1290,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "Command",
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1306,10 +1299,1609 @@ class ProcessApi:
         return response_data.response
 
 
-    def _get_session_command_serialize(
+    def _delete_session_serialize(
+        self,
+        session_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='DELETE',
+            resource_path='/process/session/{sessionId}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def execute_command(
+        self,
+        request: Annotated[ExecuteRequest, Field(description="Command execution request")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ExecuteResponse:
+        """Execute a command
+
+        Execute a shell command and return the output and exit code
+
+        :param request: Command execution request (required)
+        :type request: ExecuteRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._execute_command_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExecuteResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def execute_command_with_http_info(
+        self,
+        request: Annotated[ExecuteRequest, Field(description="Command execution request")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[ExecuteResponse]:
+        """Execute a command
+
+        Execute a shell command and return the output and exit code
+
+        :param request: Command execution request (required)
+        :type request: ExecuteRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._execute_command_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExecuteResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def execute_command_without_preload_content(
+        self,
+        request: Annotated[ExecuteRequest, Field(description="Command execution request")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Execute a command
+
+        Execute a shell command and return the output and exit code
+
+        :param request: Command execution request (required)
+        :type request: ExecuteRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._execute_command_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExecuteResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _execute_command_serialize(
+        self,
+        request,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if request is not None:
+            _body_params = request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/process/execute',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_pty_session(
+        self,
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> PtySessionInfo:
+        """Get PTY session information
+
+        Get detailed information about a specific pseudo-terminal session
+
+        :param session_id: PTY session ID (required)
+        :type session_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_pty_session_serialize(
+            session_id=session_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PtySessionInfo",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_pty_session_with_http_info(
+        self,
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[PtySessionInfo]:
+        """Get PTY session information
+
+        Get detailed information about a specific pseudo-terminal session
+
+        :param session_id: PTY session ID (required)
+        :type session_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_pty_session_serialize(
+            session_id=session_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PtySessionInfo",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_pty_session_without_preload_content(
+        self,
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get PTY session information
+
+        Get detailed information about a specific pseudo-terminal session
+
+        :param session_id: PTY session ID (required)
+        :type session_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_pty_session_serialize(
+            session_id=session_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PtySessionInfo",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_pty_session_serialize(
+        self,
+        session_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/process/pty/{sessionId}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_session(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Session:
+        """Get session details
+
+        Get details of a specific session including its commands
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_serialize(
+            session_id=session_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Session",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_session_with_http_info(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Session]:
+        """Get session details
+
+        Get details of a specific session including its commands
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_serialize(
+            session_id=session_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Session",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_session_without_preload_content(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get session details
+
+        Get details of a specific session including its commands
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_serialize(
+            session_id=session_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Session",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_session_serialize(
+        self,
+        session_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/process/session/{sessionId}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_session_command(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        command_id: Annotated[StrictStr, Field(description="Command ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Command:
+        """Get session command details
+
+        Get details of a specific command within a session
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param command_id: Command ID (required)
+        :type command_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_command_serialize(
+            session_id=session_id,
+            command_id=command_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Command",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_session_command_with_http_info(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        command_id: Annotated[StrictStr, Field(description="Command ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Command]:
+        """Get session command details
+
+        Get details of a specific command within a session
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param command_id: Command ID (required)
+        :type command_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_command_serialize(
+            session_id=session_id,
+            command_id=command_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Command",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_session_command_without_preload_content(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        command_id: Annotated[StrictStr, Field(description="Command ID")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get session command details
+
+        Get details of a specific command within a session
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param command_id: Command ID (required)
+        :type command_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_command_serialize(
+            session_id=session_id,
+            command_id=command_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Command",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_session_command_serialize(
+        self,
+        session_id,
+        command_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
+        if command_id is not None:
+            _path_params['commandId'] = command_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/process/session/{sessionId}/command/{commandId}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_session_command_logs(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        command_id: Annotated[StrictStr, Field(description="Command ID")],
+        follow: Annotated[Optional[StrictBool], Field(description="Follow logs in real-time (WebSocket only)")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> str:
+        """Get session command logs
+
+        Get logs for a specific command within a session. Supports both HTTP and WebSocket streaming.
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param command_id: Command ID (required)
+        :type command_id: str
+        :param follow: Follow logs in real-time (WebSocket only)
+        :type follow: bool
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_command_logs_serialize(
+            session_id=session_id,
+            command_id=command_id,
+            follow=follow,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "str",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_session_command_logs_with_http_info(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        command_id: Annotated[StrictStr, Field(description="Command ID")],
+        follow: Annotated[Optional[StrictBool], Field(description="Follow logs in real-time (WebSocket only)")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[str]:
+        """Get session command logs
+
+        Get logs for a specific command within a session. Supports both HTTP and WebSocket streaming.
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param command_id: Command ID (required)
+        :type command_id: str
+        :param follow: Follow logs in real-time (WebSocket only)
+        :type follow: bool
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_command_logs_serialize(
+            session_id=session_id,
+            command_id=command_id,
+            follow=follow,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "str",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_session_command_logs_without_preload_content(
+        self,
+        session_id: Annotated[StrictStr, Field(description="Session ID")],
+        command_id: Annotated[StrictStr, Field(description="Command ID")],
+        follow: Annotated[Optional[StrictBool], Field(description="Follow logs in real-time (WebSocket only)")] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get session command logs
+
+        Get logs for a specific command within a session. Supports both HTTP and WebSocket streaming.
+
+        :param session_id: Session ID (required)
+        :type session_id: str
+        :param command_id: Command ID (required)
+        :type command_id: str
+        :param follow: Follow logs in real-time (WebSocket only)
+        :type follow: bool
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_session_command_logs_serialize(
+            session_id=session_id,
+            command_id=command_id,
+            follow=follow,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "str",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_session_command_logs_serialize(
         self,
         session_id,
         command_id,
+        follow,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
+        if command_id is not None:
+            _path_params['commandId'] = command_id
+        # process the query parameters
+        if follow is not None:
+            
+            _query_params.append(('follow', follow))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/plain'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/process/session/{sessionId}/command/{commandId}/logs',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def list_pty_sessions(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> PtyListResponse:
+        """List all PTY sessions
+
+        Get a list of all active pseudo-terminal sessions
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._list_pty_sessions_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PtyListResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def list_pty_sessions_with_http_info(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[PtyListResponse]:
+        """List all PTY sessions
+
+        Get a list of all active pseudo-terminal sessions
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._list_pty_sessions_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PtyListResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def list_pty_sessions_without_preload_content(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """List all PTY sessions
+
+        Get a list of all active pseudo-terminal sessions
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._list_pty_sessions_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PtyListResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _list_pty_sessions_serialize(
+        self,
         _request_auth,
         _content_type,
         _headers,
@@ -1331,10 +2923,6 @@ class ProcessApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if session_id is not None:
-            _path_params['sessionId'] = session_id
-        if command_id is not None:
-            _path_params['commandId'] = command_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
@@ -1356,7 +2944,7 @@ class ProcessApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/process/session/{sessionId}/command/{commandId}',
+            resource_path='/process/pty',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1373,11 +2961,8 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_command_logs(
+    def list_sessions(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
-        command_id: Annotated[StrictStr, Field(description="Command ID")],
-        follow: Annotated[Optional[StrictBool], Field(description="Follow logs in real-time (WebSocket only)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1390,17 +2975,11 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> str:
-        """Get session command logs
+    ) -> List[Session]:
+        """List all sessions
 
-        Get logs for a specific command within a session. Supports both HTTP and WebSocket streaming.
+        Get a list of all active shell sessions
 
-        :param session_id: Session ID (required)
-        :type session_id: str
-        :param command_id: Command ID (required)
-        :type command_id: str
-        :param follow: Follow logs in real-time (WebSocket only)
-        :type follow: bool
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1423,10 +3002,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_command_logs_serialize(
-            session_id=session_id,
-            command_id=command_id,
-            follow=follow,
+        _param = self._list_sessions_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1434,7 +3010,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "List[Session]",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1448,11 +3024,8 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_command_logs_with_http_info(
+    def list_sessions_with_http_info(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
-        command_id: Annotated[StrictStr, Field(description="Command ID")],
-        follow: Annotated[Optional[StrictBool], Field(description="Follow logs in real-time (WebSocket only)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1465,17 +3038,11 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[str]:
-        """Get session command logs
+    ) -> ApiResponse[List[Session]]:
+        """List all sessions
 
-        Get logs for a specific command within a session. Supports both HTTP and WebSocket streaming.
+        Get a list of all active shell sessions
 
-        :param session_id: Session ID (required)
-        :type session_id: str
-        :param command_id: Command ID (required)
-        :type command_id: str
-        :param follow: Follow logs in real-time (WebSocket only)
-        :type follow: bool
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1498,10 +3065,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_command_logs_serialize(
-            session_id=session_id,
-            command_id=command_id,
-            follow=follow,
+        _param = self._list_sessions_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1509,7 +3073,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "List[Session]",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1523,11 +3087,8 @@ class ProcessApi:
 
 
     @validate_call
-    def get_session_command_logs_without_preload_content(
+    def list_sessions_without_preload_content(
         self,
-        session_id: Annotated[StrictStr, Field(description="Session ID")],
-        command_id: Annotated[StrictStr, Field(description="Command ID")],
-        follow: Annotated[Optional[StrictBool], Field(description="Follow logs in real-time (WebSocket only)")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1541,16 +3102,10 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Get session command logs
+        """List all sessions
 
-        Get logs for a specific command within a session. Supports both HTTP and WebSocket streaming.
+        Get a list of all active shell sessions
 
-        :param session_id: Session ID (required)
-        :type session_id: str
-        :param command_id: Command ID (required)
-        :type command_id: str
-        :param follow: Follow logs in real-time (WebSocket only)
-        :type follow: bool
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1573,10 +3128,7 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_session_command_logs_serialize(
-            session_id=session_id,
-            command_id=command_id,
-            follow=follow,
+        _param = self._list_sessions_serialize(
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1584,7 +3136,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "List[Session]",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1593,11 +3145,8 @@ class ProcessApi:
         return response_data.response
 
 
-    def _get_session_command_logs_serialize(
+    def _list_sessions_serialize(
         self,
-        session_id,
-        command_id,
-        follow,
         _request_auth,
         _content_type,
         _headers,
@@ -1619,15 +3168,7 @@ class ProcessApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        if session_id is not None:
-            _path_params['sessionId'] = session_id
-        if command_id is not None:
-            _path_params['commandId'] = command_id
         # process the query parameters
-        if follow is not None:
-            
-            _query_params.append(('follow', follow))
-            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -1637,7 +3178,7 @@ class ProcessApi:
         if 'Accept' not in _header_params:
             _header_params['Accept'] = self.api_client.select_header_accept(
                 [
-                    'text/plain'
+                    'application/json'
                 ]
             )
 
@@ -1648,7 +3189,7 @@ class ProcessApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/process/session/{sessionId}/command/{commandId}/logs',
+            resource_path='/process/session',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1665,8 +3206,10 @@ class ProcessApi:
 
 
     @validate_call
-    def list_sessions(
+    def resize_pty_session(
         self,
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
+        request: Annotated[PtyResizeRequest, Field(description="Resize request with new dimensions")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1679,11 +3222,15 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> List[Session]:
-        """List all sessions
+    ) -> PtySessionInfo:
+        """Resize a PTY session
 
-        Get a list of all active shell sessions
+        Resize the terminal dimensions of a pseudo-terminal session
 
+        :param session_id: PTY session ID (required)
+        :type session_id: str
+        :param request: Resize request with new dimensions (required)
+        :type request: PtyResizeRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1706,7 +3253,9 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._list_sessions_serialize(
+        _param = self._resize_pty_session_serialize(
+            session_id=session_id,
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1714,7 +3263,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[Session]",
+            '200': "PtySessionInfo",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1728,8 +3277,10 @@ class ProcessApi:
 
 
     @validate_call
-    def list_sessions_with_http_info(
+    def resize_pty_session_with_http_info(
         self,
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
+        request: Annotated[PtyResizeRequest, Field(description="Resize request with new dimensions")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1742,11 +3293,15 @@ class ProcessApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[List[Session]]:
-        """List all sessions
+    ) -> ApiResponse[PtySessionInfo]:
+        """Resize a PTY session
 
-        Get a list of all active shell sessions
+        Resize the terminal dimensions of a pseudo-terminal session
 
+        :param session_id: PTY session ID (required)
+        :type session_id: str
+        :param request: Resize request with new dimensions (required)
+        :type request: PtyResizeRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1769,7 +3324,9 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._list_sessions_serialize(
+        _param = self._resize_pty_session_serialize(
+            session_id=session_id,
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1777,7 +3334,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[Session]",
+            '200': "PtySessionInfo",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1791,8 +3348,10 @@ class ProcessApi:
 
 
     @validate_call
-    def list_sessions_without_preload_content(
+    def resize_pty_session_without_preload_content(
         self,
+        session_id: Annotated[StrictStr, Field(description="PTY session ID")],
+        request: Annotated[PtyResizeRequest, Field(description="Resize request with new dimensions")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1806,10 +3365,14 @@ class ProcessApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """List all sessions
+        """Resize a PTY session
 
-        Get a list of all active shell sessions
+        Resize the terminal dimensions of a pseudo-terminal session
 
+        :param session_id: PTY session ID (required)
+        :type session_id: str
+        :param request: Resize request with new dimensions (required)
+        :type request: PtyResizeRequest
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1832,7 +3395,9 @@ class ProcessApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._list_sessions_serialize(
+        _param = self._resize_pty_session_serialize(
+            session_id=session_id,
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1840,7 +3405,7 @@ class ProcessApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "List[Session]",
+            '200': "PtySessionInfo",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1849,8 +3414,10 @@ class ProcessApi:
         return response_data.response
 
 
-    def _list_sessions_serialize(
+    def _resize_pty_session_serialize(
         self,
+        session_id,
+        request,
         _request_auth,
         _content_type,
         _headers,
@@ -1872,10 +3439,14 @@ class ProcessApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if session_id is not None:
+            _path_params['sessionId'] = session_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if request is not None:
+            _body_params = request
 
 
         # set the HTTP header `Accept`
@@ -1886,14 +3457,27 @@ class ProcessApi:
                 ]
             )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/process/session',
+            method='POST',
+            resource_path='/process/pty/{sessionId}/resize',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,