daytona_api_client 0.164.0.alpha.1 → 1.0.0

data/lib/daytona_api_client/api/sandbox_api.rb

@@ -20,38 +20,36 @@ module DaytonaApiClient
       @api_client = api_client
     end
     # Archive sandbox
-    # @param sandbox_id_or_name [String] 
+    # @param sandbox_id [String] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def archive_sandbox(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = archive_sandbox_with_http_info(sandbox_id_or_name, opts)
-      data
+    # @return [nil]
+    def archive_sandbox(sandbox_id, opts = {})
+      archive_sandbox_with_http_info(sandbox_id, opts)
+      nil
     end
 
     # Archive sandbox
-    # @param sandbox_id_or_name [String] 
+    # @param sandbox_id [String] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def archive_sandbox_with_http_info(sandbox_id_or_name, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def archive_sandbox_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.archive_sandbox ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.archive_sandbox"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.archive_sandbox"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/archive'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/archive'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -61,7 +59,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -84,30 +82,30 @@ module DaytonaApiClient
     end
 
     # Create sandbox backup
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Sandbox]
-    def create_backup(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = create_backup_with_http_info(sandbox_id_or_name, opts)
+    def create_backup(sandbox_id, opts = {})
+      data, _status_code, _headers = create_backup_with_http_info(sandbox_id, opts)
       data
     end
 
     # Create sandbox backup
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def create_backup_with_http_info(sandbox_id_or_name, opts = {})
+    def create_backup_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.create_backup ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.create_backup"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.create_backup"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/backup'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/backup'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -183,7 +181,7 @@ module DaytonaApiClient
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
@@ -217,32 +215,32 @@ module DaytonaApiClient
     end
 
     # Create SSH access for sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [Float] :expires_in_minutes Expiration time in minutes (default: 60)
     # @return [SshAccessDto]
-    def create_ssh_access(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = create_ssh_access_with_http_info(sandbox_id_or_name, opts)
+    def create_ssh_access(sandbox_id, opts = {})
+      data, _status_code, _headers = create_ssh_access_with_http_info(sandbox_id, opts)
       data
     end
 
     # Create SSH access for sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [Float] :expires_in_minutes Expiration time in minutes (default: 60)
     # @return [Array<(SshAccessDto, Integer, Hash)>] SshAccessDto data, response status code and response headers
-    def create_ssh_access_with_http_info(sandbox_id_or_name, opts = {})
+    def create_ssh_access_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.create_ssh_access ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.create_ssh_access"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.create_ssh_access"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/ssh-access'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/ssh-access'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -284,38 +282,36 @@ module DaytonaApiClient
     end
 
     # Delete sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def delete_sandbox(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = delete_sandbox_with_http_info(sandbox_id_or_name, opts)
-      data
+    # @return [nil]
+    def delete_sandbox(sandbox_id, opts = {})
+      delete_sandbox_with_http_info(sandbox_id, opts)
+      nil
     end
 
     # Delete sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def delete_sandbox_with_http_info(sandbox_id_or_name, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def delete_sandbox_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.delete_sandbox ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.delete_sandbox"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.delete_sandbox"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -325,7 +321,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -347,109 +343,33 @@ module DaytonaApiClient
       return data, status_code, headers
     end
 
-    # Expire signed preview URL for a sandbox port
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param port [Integer] Port number to expire signed preview URL for
-    # @param token [String] Token to expire signed preview URL for
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [nil]
-    def expire_signed_port_preview_url(sandbox_id_or_name, port, token, opts = {})
-      expire_signed_port_preview_url_with_http_info(sandbox_id_or_name, port, token, opts)
-      nil
-    end
-
-    # Expire signed preview URL for a sandbox port
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param port [Integer] Port number to expire signed preview URL for
-    # @param token [String] Token to expire signed preview URL for
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def expire_signed_port_preview_url_with_http_info(sandbox_id_or_name, port, token, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.expire_signed_port_preview_url ...'
-      end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.expire_signed_port_preview_url"
-      end
-      # verify the required parameter 'port' is set
-      if @api_client.config.client_side_validation && port.nil?
-        fail ArgumentError, "Missing the required parameter 'port' when calling SandboxApi.expire_signed_port_preview_url"
-      end
-      # verify the required parameter 'token' is set
-      if @api_client.config.client_side_validation && token.nil?
-        fail ArgumentError, "Missing the required parameter 'token' when calling SandboxApi.expire_signed_port_preview_url"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/ports/{port}/signed-preview-url/{token}/expire'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'port' + '}', CGI.escape(port.to_s)).sub('{' + 'token' + '}', CGI.escape(token.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type]
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.expire_signed_port_preview_url",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#expire_signed_port_preview_url\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
     # Get build logs
-    # This endpoint is deprecated. Use `getBuildLogsUrl` instead.
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [Boolean] :follow Whether to follow the logs stream
     # @return [nil]
-    def get_build_logs(sandbox_id_or_name, opts = {})
-      get_build_logs_with_http_info(sandbox_id_or_name, opts)
+    def get_build_logs(sandbox_id, opts = {})
+      get_build_logs_with_http_info(sandbox_id, opts)
       nil
     end
 
     # Get build logs
-    # This endpoint is deprecated. Use &#x60;getBuildLogsUrl&#x60; instead.
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [Boolean] :follow Whether to follow the logs stream
     # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def get_build_logs_with_http_info(sandbox_id_or_name, opts = {})
+    def get_build_logs_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.get_build_logs ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.get_build_logs"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_build_logs"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/build-logs'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/build-logs'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -488,101 +408,37 @@ module DaytonaApiClient
       return data, status_code, headers
     end
 
-    # Get build logs URL
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Url]
-    def get_build_logs_url(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = get_build_logs_url_with_http_info(sandbox_id_or_name, opts)
-      data
-    end
-
-    # Get build logs URL
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Url, Integer, Hash)>] Url data, response status code and response headers
-    def get_build_logs_url_with_http_info(sandbox_id_or_name, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_build_logs_url ...'
-      end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.get_build_logs_url"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/build-logs-url'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'Url'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.get_build_logs_url",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_build_logs_url\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
     # Get preview URL for a sandbox port
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param port [Float] Port number to get preview URL for
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [PortPreviewUrl]
-    def get_port_preview_url(sandbox_id_or_name, port, opts = {})
-      data, _status_code, _headers = get_port_preview_url_with_http_info(sandbox_id_or_name, port, opts)
+    def get_port_preview_url(sandbox_id, port, opts = {})
+      data, _status_code, _headers = get_port_preview_url_with_http_info(sandbox_id, port, opts)
       data
     end
 
     # Get preview URL for a sandbox port
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param port [Float] Port number to get preview URL for
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Array<(PortPreviewUrl, Integer, Hash)>] PortPreviewUrl data, response status code and response headers
-    def get_port_preview_url_with_http_info(sandbox_id_or_name, port, opts = {})
+    def get_port_preview_url_with_http_info(sandbox_id, port, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.get_port_preview_url ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.get_port_preview_url"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_port_preview_url"
       end
       # verify the required parameter 'port' is set
       if @api_client.config.client_side_validation && port.nil?
         fail ArgumentError, "Missing the required parameter 'port' when calling SandboxApi.get_port_preview_url"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/ports/{port}/preview-url'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'port' + '}', CGI.escape(port.to_s))
+      local_var_path = '/sandbox/{sandboxId}/ports/{port}/preview-url'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s)).sub('{' + 'port' + '}', CGI.escape(port.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -623,32 +479,32 @@ module DaytonaApiClient
     end
 
     # Get sandbox details
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [Boolean] :verbose Include verbose output
     # @return [Sandbox]
-    def get_sandbox(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = get_sandbox_with_http_info(sandbox_id_or_name, opts)
+    def get_sandbox(sandbox_id, opts = {})
+      data, _status_code, _headers = get_sandbox_with_http_info(sandbox_id, opts)
       data
     end
 
     # Get sandbox details
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [Boolean] :verbose Include verbose output
     # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def get_sandbox_with_http_info(sandbox_id_or_name, opts = {})
+    def get_sandbox_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandbox ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.get_sandbox"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_sandbox"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -689,145 +545,28 @@ module DaytonaApiClient
       return data, status_code, headers
     end
 
-    # Get sandbox logs
-    # Retrieve OTEL logs for a sandbox within a time range
-    # @param sandbox_id [String] ID of the sandbox
-    # @param from [Time] Start of time range (ISO 8601)
-    # @param to [Time] End of time range (ISO 8601)
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Float] :page Page number (1-indexed) (default to 1)
-    # @option opts [Float] :limit Number of items per page (default to 100)
-    # @option opts [Array<String>] :severities Filter by severity levels (DEBUG, INFO, WARN, ERROR)
-    # @option opts [String] :search Search in log body
-    # @return [PaginatedLogs]
-    def get_sandbox_logs(sandbox_id, from, to, opts = {})
-      data, _status_code, _headers = get_sandbox_logs_with_http_info(sandbox_id, from, to, opts)
-      data
-    end
-
-    # Get sandbox logs
-    # Retrieve OTEL logs for a sandbox within a time range
-    # @param sandbox_id [String] ID of the sandbox
-    # @param from [Time] Start of time range (ISO 8601)
-    # @param to [Time] End of time range (ISO 8601)
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Float] :page Page number (1-indexed) (default to 1)
-    # @option opts [Float] :limit Number of items per page (default to 100)
-    # @option opts [Array<String>] :severities Filter by severity levels (DEBUG, INFO, WARN, ERROR)
-    # @option opts [String] :search Search in log body
-    # @return [Array<(PaginatedLogs, Integer, Hash)>] PaginatedLogs data, response status code and response headers
-    def get_sandbox_logs_with_http_info(sandbox_id, from, to, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandbox_logs ...'
-      end
-      # verify the required parameter 'sandbox_id' is set
-      if @api_client.config.client_side_validation && sandbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_sandbox_logs"
-      end
-      # verify the required parameter 'from' is set
-      if @api_client.config.client_side_validation && from.nil?
-        fail ArgumentError, "Missing the required parameter 'from' when calling SandboxApi.get_sandbox_logs"
-      end
-      # verify the required parameter 'to' is set
-      if @api_client.config.client_side_validation && to.nil?
-        fail ArgumentError, "Missing the required parameter 'to' when calling SandboxApi.get_sandbox_logs"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxId}/telemetry/logs'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-      query_params[:'from'] = from
-      query_params[:'to'] = to
-      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
-      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
-      query_params[:'severities'] = @api_client.build_collection_param(opts[:'severities'], :multi) if !opts[:'severities'].nil?
-      query_params[:'search'] = opts[:'search'] if !opts[:'search'].nil?
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'PaginatedLogs'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.get_sandbox_logs",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_sandbox_logs\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
-    # Get sandbox metrics
-    # Retrieve OTEL metrics for a sandbox within a time range
-    # @param sandbox_id [String] ID of the sandbox
-    # @param from [Time] Start of time range (ISO 8601)
-    # @param to [Time] End of time range (ISO 8601)
+    # List all regions where sandboxes have been created
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Array<String>] :metric_names Filter by metric names
-    # @return [MetricsResponse]
-    def get_sandbox_metrics(sandbox_id, from, to, opts = {})
-      data, _status_code, _headers = get_sandbox_metrics_with_http_info(sandbox_id, from, to, opts)
+    # @return [Array<Region>]
+    def get_sandbox_regions(opts = {})
+      data, _status_code, _headers = get_sandbox_regions_with_http_info(opts)
       data
     end
 
-    # Get sandbox metrics
-    # Retrieve OTEL metrics for a sandbox within a time range
-    # @param sandbox_id [String] ID of the sandbox
-    # @param from [Time] Start of time range (ISO 8601)
-    # @param to [Time] End of time range (ISO 8601)
+    # List all regions where sandboxes have been created
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Array<String>] :metric_names Filter by metric names
-    # @return [Array<(MetricsResponse, Integer, Hash)>] MetricsResponse data, response status code and response headers
-    def get_sandbox_metrics_with_http_info(sandbox_id, from, to, opts = {})
+    # @return [Array<(Array<Region>, Integer, Hash)>] Array<Region> data, response status code and response headers
+    def get_sandbox_regions_with_http_info(opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandbox_metrics ...'
-      end
-      # verify the required parameter 'sandbox_id' is set
-      if @api_client.config.client_side_validation && sandbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_sandbox_metrics"
-      end
-      # verify the required parameter 'from' is set
-      if @api_client.config.client_side_validation && from.nil?
-        fail ArgumentError, "Missing the required parameter 'from' when calling SandboxApi.get_sandbox_metrics"
-      end
-      # verify the required parameter 'to' is set
-      if @api_client.config.client_side_validation && to.nil?
-        fail ArgumentError, "Missing the required parameter 'to' when calling SandboxApi.get_sandbox_metrics"
+        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandbox_regions ...'
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxId}/telemetry/metrics'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
+      local_var_path = '/sandbox/regions'
 
       # query parameters
       query_params = opts[:query_params] || {}
-      query_params[:'from'] = from
-      query_params[:'to'] = to
-      query_params[:'metricNames'] = @api_client.build_collection_param(opts[:'metric_names'], :multi) if !opts[:'metric_names'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -842,13 +581,13 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'MetricsResponse'
+      return_type = opts[:debug_return_type] || 'Array<Region>'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
 
       new_options = opts.merge(
-        :operation => :"SandboxApi.get_sandbox_metrics",
+        :operation => :"SandboxApi.get_sandbox_regions",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -859,165 +598,7 @@ module DaytonaApiClient
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_sandbox_metrics\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
-    # Get trace spans
-    # Retrieve all spans for a specific trace
-    # @param sandbox_id [String] ID of the sandbox
-    # @param trace_id [String] ID of the trace
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<TraceSpan>]
-    def get_sandbox_trace_spans(sandbox_id, trace_id, opts = {})
-      data, _status_code, _headers = get_sandbox_trace_spans_with_http_info(sandbox_id, trace_id, opts)
-      data
-    end
-
-    # Get trace spans
-    # Retrieve all spans for a specific trace
-    # @param sandbox_id [String] ID of the sandbox
-    # @param trace_id [String] ID of the trace
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Array<TraceSpan>, Integer, Hash)>] Array<TraceSpan> data, response status code and response headers
-    def get_sandbox_trace_spans_with_http_info(sandbox_id, trace_id, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandbox_trace_spans ...'
-      end
-      # verify the required parameter 'sandbox_id' is set
-      if @api_client.config.client_side_validation && sandbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_sandbox_trace_spans"
-      end
-      # verify the required parameter 'trace_id' is set
-      if @api_client.config.client_side_validation && trace_id.nil?
-        fail ArgumentError, "Missing the required parameter 'trace_id' when calling SandboxApi.get_sandbox_trace_spans"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxId}/telemetry/traces/{traceId}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s)).sub('{' + 'traceId' + '}', CGI.escape(trace_id.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'Array<TraceSpan>'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.get_sandbox_trace_spans",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_sandbox_trace_spans\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
-    # Get sandbox traces
-    # Retrieve OTEL traces for a sandbox within a time range
-    # @param sandbox_id [String] ID of the sandbox
-    # @param from [Time] Start of time range (ISO 8601)
-    # @param to [Time] End of time range (ISO 8601)
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Float] :page Page number (1-indexed) (default to 1)
-    # @option opts [Float] :limit Number of items per page (default to 100)
-    # @return [PaginatedTraces]
-    def get_sandbox_traces(sandbox_id, from, to, opts = {})
-      data, _status_code, _headers = get_sandbox_traces_with_http_info(sandbox_id, from, to, opts)
-      data
-    end
-
-    # Get sandbox traces
-    # Retrieve OTEL traces for a sandbox within a time range
-    # @param sandbox_id [String] ID of the sandbox
-    # @param from [Time] Start of time range (ISO 8601)
-    # @param to [Time] End of time range (ISO 8601)
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Float] :page Page number (1-indexed) (default to 1)
-    # @option opts [Float] :limit Number of items per page (default to 100)
-    # @return [Array<(PaginatedTraces, Integer, Hash)>] PaginatedTraces data, response status code and response headers
-    def get_sandbox_traces_with_http_info(sandbox_id, from, to, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandbox_traces ...'
-      end
-      # verify the required parameter 'sandbox_id' is set
-      if @api_client.config.client_side_validation && sandbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_sandbox_traces"
-      end
-      # verify the required parameter 'from' is set
-      if @api_client.config.client_side_validation && from.nil?
-        fail ArgumentError, "Missing the required parameter 'from' when calling SandboxApi.get_sandbox_traces"
-      end
-      # verify the required parameter 'to' is set
-      if @api_client.config.client_side_validation && to.nil?
-        fail ArgumentError, "Missing the required parameter 'to' when calling SandboxApi.get_sandbox_traces"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxId}/telemetry/traces'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-      query_params[:'from'] = from
-      query_params[:'to'] = to
-      query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
-      query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'PaginatedTraces'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.get_sandbox_traces",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_sandbox_traces\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: SandboxApi#get_sandbox_regions\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -1033,160 +614,23 @@ module DaytonaApiClient
       data
     end
 
-    # Get sandboxes for the authenticated runner
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [String] :states Comma-separated list of sandbox states to filter by
-    # @option opts [Boolean] :skip_reconciling_sandboxes Skip sandboxes where state differs from desired state
-    # @return [Array<(Array<Sandbox>, Integer, Hash)>] Array<Sandbox> data, response status code and response headers
-    def get_sandboxes_for_runner_with_http_info(opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandboxes_for_runner ...'
-      end
-      # resource path
-      local_var_path = '/sandbox/for-runner'
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-      query_params[:'states'] = opts[:'states'] if !opts[:'states'].nil?
-      query_params[:'skipReconcilingSandboxes'] = opts[:'skip_reconciling_sandboxes'] if !opts[:'skip_reconciling_sandboxes'].nil?
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'Array<Sandbox>'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.get_sandboxes_for_runner",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_sandboxes_for_runner\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
-    # Get signed preview URL for a sandbox port
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param port [Integer] Port number to get signed preview URL for
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Integer] :expires_in_seconds Expiration time in seconds (default: 60 seconds)
-    # @return [SignedPortPreviewUrl]
-    def get_signed_port_preview_url(sandbox_id_or_name, port, opts = {})
-      data, _status_code, _headers = get_signed_port_preview_url_with_http_info(sandbox_id_or_name, port, opts)
-      data
-    end
-
-    # Get signed preview URL for a sandbox port
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param port [Integer] Port number to get signed preview URL for
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Integer] :expires_in_seconds Expiration time in seconds (default: 60 seconds)
-    # @return [Array<(SignedPortPreviewUrl, Integer, Hash)>] SignedPortPreviewUrl data, response status code and response headers
-    def get_signed_port_preview_url_with_http_info(sandbox_id_or_name, port, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_signed_port_preview_url ...'
-      end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.get_signed_port_preview_url"
-      end
-      # verify the required parameter 'port' is set
-      if @api_client.config.client_side_validation && port.nil?
-        fail ArgumentError, "Missing the required parameter 'port' when calling SandboxApi.get_signed_port_preview_url"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/ports/{port}/signed-preview-url'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'port' + '}', CGI.escape(port.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-      query_params[:'expiresInSeconds'] = opts[:'expires_in_seconds'] if !opts[:'expires_in_seconds'].nil?
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'SignedPortPreviewUrl'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.get_signed_port_preview_url",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_signed_port_preview_url\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
-    # Get toolbox proxy URL for a sandbox
-    # @param sandbox_id [String] ID of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [ToolboxProxyUrl]
-    def get_toolbox_proxy_url(sandbox_id, opts = {})
-      data, _status_code, _headers = get_toolbox_proxy_url_with_http_info(sandbox_id, opts)
-      data
-    end
-
-    # Get toolbox proxy URL for a sandbox
-    # @param sandbox_id [String] ID of the sandbox
+    # Get sandboxes for the authenticated runner
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(ToolboxProxyUrl, Integer, Hash)>] ToolboxProxyUrl data, response status code and response headers
-    def get_toolbox_proxy_url_with_http_info(sandbox_id, opts = {})
+    # @option opts [String] :states Comma-separated list of sandbox states to filter by
+    # @option opts [Boolean] :skip_reconciling_sandboxes Skip sandboxes where state differs from desired state
+    # @return [Array<(Array<Sandbox>, Integer, Hash)>] Array<Sandbox> data, response status code and response headers
+    def get_sandboxes_for_runner_with_http_info(opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.get_toolbox_proxy_url ...'
-      end
-      # verify the required parameter 'sandbox_id' is set
-      if @api_client.config.client_side_validation && sandbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.get_toolbox_proxy_url"
+        @api_client.config.logger.debug 'Calling API: SandboxApi.get_sandboxes_for_runner ...'
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxId}/toolbox-proxy-url'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
+      local_var_path = '/sandbox/for-runner'
 
       # query parameters
       query_params = opts[:query_params] || {}
+      query_params[:'states'] = opts[:'states'] if !opts[:'states'].nil?
+      query_params[:'skipReconcilingSandboxes'] = opts[:'skip_reconciling_sandboxes'] if !opts[:'skip_reconciling_sandboxes'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -1201,13 +645,13 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'ToolboxProxyUrl'
+      return_type = opts[:debug_return_type] || 'Array<Sandbox>'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
 
       new_options = opts.merge(
-        :operation => :"SandboxApi.get_toolbox_proxy_url",
+        :operation => :"SandboxApi.get_sandboxes_for_runner",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -1218,7 +662,7 @@ module DaytonaApiClient
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#get_toolbox_proxy_url\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: SandboxApi#get_sandboxes_for_runner\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -1296,7 +740,6 @@ module DaytonaApiClient
     # @option opts [Float] :page Page number of the results (default to 1)
     # @option opts [Float] :limit Number of results per page (default to 100)
     # @option opts [String] :id Filter by partial ID match
-    # @option opts [String] :name Filter by partial name match
     # @option opts [String] :labels JSON encoded labels to filter by
     # @option opts [Boolean] :include_errored_deleted Include results with errored state and deleted desired state (default to false)
     # @option opts [Array<String>] :states List of states to filter by
@@ -1324,7 +767,6 @@ module DaytonaApiClient
     # @option opts [Float] :page Page number of the results (default to 1)
     # @option opts [Float] :limit Number of results per page (default to 100)
     # @option opts [String] :id Filter by partial ID match
-    # @option opts [String] :name Filter by partial name match
     # @option opts [String] :labels JSON encoded labels to filter by
     # @option opts [Boolean] :include_errored_deleted Include results with errored state and deleted desired state (default to false)
     # @option opts [Array<String>] :states List of states to filter by
@@ -1357,7 +799,7 @@ module DaytonaApiClient
         fail ArgumentError, 'invalid value for "opts[:"limit"]" when calling SandboxApi.list_sandboxes_paginated, must be greater than or equal to 1.'
       end
 
-      allowable_values = ["creating", "restoring", "destroying", "started", "stopped", "starting", "stopping", "error", "build_failed", "pending_build", "building_snapshot", "unknown", "pulling_snapshot", "archived", "archiving", "resizing"]
+      allowable_values = ["creating", "restoring", "destroying", "started", "stopped", "starting", "stopping", "error", "build_failed", "pending_build", "building_snapshot", "unknown", "pulling_snapshot", "archived", "archiving"]
       if @api_client.config.client_side_validation && opts[:'states'] && !opts[:'states'].all? { |item| allowable_values.include?(item) }
         fail ArgumentError, "invalid value for \"states\", must include one of #{allowable_values}"
       end
@@ -1385,7 +827,7 @@ module DaytonaApiClient
         fail ArgumentError, 'invalid value for "opts[:"max_disk_gi_b"]" when calling SandboxApi.list_sandboxes_paginated, must be greater than or equal to 1.'
       end
 
-      allowable_values = ["id", "name", "state", "snapshot", "region", "updatedAt", "createdAt"]
+      allowable_values = ["id", "state", "snapshot", "region", "updatedAt", "createdAt"]
       if @api_client.config.client_side_validation && opts[:'sort'] && !allowable_values.include?(opts[:'sort'])
         fail ArgumentError, "invalid value for \"sort\", must be one of #{allowable_values}"
       end
@@ -1401,7 +843,6 @@ module DaytonaApiClient
       query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
       query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?
       query_params[:'id'] = opts[:'id'] if !opts[:'id'].nil?
-      query_params[:'name'] = opts[:'name'] if !opts[:'name'].nil?
       query_params[:'labels'] = opts[:'labels'] if !opts[:'labels'].nil?
       query_params[:'includeErroredDeleted'] = opts[:'include_errored_deleted'] if !opts[:'include_errored_deleted'].nil?
       query_params[:'states'] = @api_client.build_collection_param(opts[:'states'], :multi) if !opts[:'states'].nil?
@@ -1453,101 +894,37 @@ module DaytonaApiClient
       return data, status_code, headers
     end
 
-    # Recover sandbox from error state
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def recover_sandbox(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = recover_sandbox_with_http_info(sandbox_id_or_name, opts)
-      data
-    end
-
-    # Recover sandbox from error state
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def recover_sandbox_with_http_info(sandbox_id_or_name, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.recover_sandbox ...'
-      end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.recover_sandbox"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/recover'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.recover_sandbox",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#recover_sandbox\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
     # Replace sandbox labels
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param sandbox_labels [SandboxLabels] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [SandboxLabels]
-    def replace_labels(sandbox_id_or_name, sandbox_labels, opts = {})
-      data, _status_code, _headers = replace_labels_with_http_info(sandbox_id_or_name, sandbox_labels, opts)
+    def replace_labels(sandbox_id, sandbox_labels, opts = {})
+      data, _status_code, _headers = replace_labels_with_http_info(sandbox_id, sandbox_labels, opts)
       data
     end
 
     # Replace sandbox labels
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param sandbox_labels [SandboxLabels] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Array<(SandboxLabels, Integer, Hash)>] SandboxLabels data, response status code and response headers
-    def replace_labels_with_http_info(sandbox_id_or_name, sandbox_labels, opts = {})
+    def replace_labels_with_http_info(sandbox_id, sandbox_labels, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.replace_labels ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.replace_labels"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.replace_labels"
       end
       # verify the required parameter 'sandbox_labels' is set
       if @api_client.config.client_side_validation && sandbox_labels.nil?
         fail ArgumentError, "Missing the required parameter 'sandbox_labels' when calling SandboxApi.replace_labels"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/labels'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/labels'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -1559,7 +936,7 @@ module DaytonaApiClient
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
@@ -1592,108 +969,33 @@ module DaytonaApiClient
       return data, status_code, headers
     end
 
-    # Resize sandbox resources
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param resize_sandbox [ResizeSandbox] 
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def resize_sandbox(sandbox_id_or_name, resize_sandbox, opts = {})
-      data, _status_code, _headers = resize_sandbox_with_http_info(sandbox_id_or_name, resize_sandbox, opts)
-      data
-    end
-
-    # Resize sandbox resources
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param resize_sandbox [ResizeSandbox] 
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def resize_sandbox_with_http_info(sandbox_id_or_name, resize_sandbox, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.resize_sandbox ...'
-      end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.resize_sandbox"
-      end
-      # verify the required parameter 'resize_sandbox' is set
-      if @api_client.config.client_side_validation && resize_sandbox.nil?
-        fail ArgumentError, "Missing the required parameter 'resize_sandbox' when calling SandboxApi.resize_sandbox"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/resize'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      # HTTP header 'Content-Type'
-      content_type = @api_client.select_header_content_type(['application/json'])
-      if !content_type.nil?
-          header_params['Content-Type'] = content_type
-      end
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(resize_sandbox)
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.resize_sandbox",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#resize_sandbox\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
     # Revoke SSH access for sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [String] :token SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.
-    # @return [Sandbox]
-    def revoke_ssh_access(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = revoke_ssh_access_with_http_info(sandbox_id_or_name, opts)
-      data
+    # @return [nil]
+    def revoke_ssh_access(sandbox_id, opts = {})
+      revoke_ssh_access_with_http_info(sandbox_id, opts)
+      nil
     end
 
     # Revoke SSH access for sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @option opts [String] :token SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def revoke_ssh_access_with_http_info(sandbox_id_or_name, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def revoke_ssh_access_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.revoke_ssh_access ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.revoke_ssh_access"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.revoke_ssh_access"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/ssh-access'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/ssh-access'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -1701,8 +1003,6 @@ module DaytonaApiClient
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -1712,7 +1012,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -1735,44 +1035,42 @@ module DaytonaApiClient
     end
 
     # Set sandbox auto-archive interval
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param interval [Float] Auto-archive interval in minutes (0 means the maximum interval will be used)
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def set_auto_archive_interval(sandbox_id_or_name, interval, opts = {})
-      data, _status_code, _headers = set_auto_archive_interval_with_http_info(sandbox_id_or_name, interval, opts)
-      data
+    # @return [nil]
+    def set_auto_archive_interval(sandbox_id, interval, opts = {})
+      set_auto_archive_interval_with_http_info(sandbox_id, interval, opts)
+      nil
     end
 
     # Set sandbox auto-archive interval
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param interval [Float] Auto-archive interval in minutes (0 means the maximum interval will be used)
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def set_auto_archive_interval_with_http_info(sandbox_id_or_name, interval, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def set_auto_archive_interval_with_http_info(sandbox_id, interval, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.set_auto_archive_interval ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.set_auto_archive_interval"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.set_auto_archive_interval"
       end
       # verify the required parameter 'interval' is set
       if @api_client.config.client_side_validation && interval.nil?
         fail ArgumentError, "Missing the required parameter 'interval' when calling SandboxApi.set_auto_archive_interval"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/autoarchive/{interval}'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'interval' + '}', CGI.escape(interval.to_s))
+      local_var_path = '/sandbox/{sandboxId}/autoarchive/{interval}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s)).sub('{' + 'interval' + '}', CGI.escape(interval.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -1782,7 +1080,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -1805,44 +1103,42 @@ module DaytonaApiClient
     end
 
     # Set sandbox auto-delete interval
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param interval [Float] Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping)
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def set_auto_delete_interval(sandbox_id_or_name, interval, opts = {})
-      data, _status_code, _headers = set_auto_delete_interval_with_http_info(sandbox_id_or_name, interval, opts)
-      data
+    # @return [nil]
+    def set_auto_delete_interval(sandbox_id, interval, opts = {})
+      set_auto_delete_interval_with_http_info(sandbox_id, interval, opts)
+      nil
     end
 
     # Set sandbox auto-delete interval
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param interval [Float] Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping)
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def set_auto_delete_interval_with_http_info(sandbox_id_or_name, interval, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def set_auto_delete_interval_with_http_info(sandbox_id, interval, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.set_auto_delete_interval ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.set_auto_delete_interval"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.set_auto_delete_interval"
       end
       # verify the required parameter 'interval' is set
       if @api_client.config.client_side_validation && interval.nil?
         fail ArgumentError, "Missing the required parameter 'interval' when calling SandboxApi.set_auto_delete_interval"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/autodelete/{interval}'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'interval' + '}', CGI.escape(interval.to_s))
+      local_var_path = '/sandbox/{sandboxId}/autodelete/{interval}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s)).sub('{' + 'interval' + '}', CGI.escape(interval.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -1852,7 +1148,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -1875,44 +1171,42 @@ module DaytonaApiClient
     end
 
     # Set sandbox auto-stop interval
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param interval [Float] Auto-stop interval in minutes (0 to disable)
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def set_autostop_interval(sandbox_id_or_name, interval, opts = {})
-      data, _status_code, _headers = set_autostop_interval_with_http_info(sandbox_id_or_name, interval, opts)
-      data
+    # @return [nil]
+    def set_autostop_interval(sandbox_id, interval, opts = {})
+      set_autostop_interval_with_http_info(sandbox_id, interval, opts)
+      nil
     end
 
     # Set sandbox auto-stop interval
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param interval [Float] Auto-stop interval in minutes (0 to disable)
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def set_autostop_interval_with_http_info(sandbox_id_or_name, interval, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def set_autostop_interval_with_http_info(sandbox_id, interval, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.set_autostop_interval ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.set_autostop_interval"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.set_autostop_interval"
       end
       # verify the required parameter 'interval' is set
       if @api_client.config.client_side_validation && interval.nil?
         fail ArgumentError, "Missing the required parameter 'interval' when calling SandboxApi.set_autostop_interval"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/autostop/{interval}'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'interval' + '}', CGI.escape(interval.to_s))
+      local_var_path = '/sandbox/{sandboxId}/autostop/{interval}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s)).sub('{' + 'interval' + '}', CGI.escape(interval.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -1922,7 +1216,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -1945,30 +1239,30 @@ module DaytonaApiClient
     end
 
     # Start sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Sandbox]
-    def start_sandbox(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = start_sandbox_with_http_info(sandbox_id_or_name, opts)
+    def start_sandbox(sandbox_id, opts = {})
+      data, _status_code, _headers = start_sandbox_with_http_info(sandbox_id, opts)
       data
     end
 
     # Start sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def start_sandbox_with_http_info(sandbox_id_or_name, opts = {})
+    def start_sandbox_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.start_sandbox ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.start_sandbox"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.start_sandbox"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/start'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
+      local_var_path = '/sandbox/{sandboxId}/start'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -2009,97 +1303,30 @@ module DaytonaApiClient
     end
 
     # Stop sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Boolean] :force Force stop the sandbox using SIGKILL instead of SIGTERM
-    # @return [Sandbox]
-    def stop_sandbox(sandbox_id_or_name, opts = {})
-      data, _status_code, _headers = stop_sandbox_with_http_info(sandbox_id_or_name, opts)
-      data
-    end
-
-    # Stop sandbox
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @option opts [Boolean] :force Force stop the sandbox using SIGKILL instead of SIGTERM
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def stop_sandbox_with_http_info(sandbox_id_or_name, opts = {})
-      if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.stop_sandbox ...'
-      end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.stop_sandbox"
-      end
-      # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/stop'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s))
-
-      # query parameters
-      query_params = opts[:query_params] || {}
-      query_params[:'force'] = opts[:'force'] if !opts[:'force'].nil?
-
-      # header parameters
-      header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
-      header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body]
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
-
-      new_options = opts.merge(
-        :operation => :"SandboxApi.stop_sandbox",
-        :header_params => header_params,
-        :query_params => query_params,
-        :form_params => form_params,
-        :body => post_body,
-        :auth_names => auth_names,
-        :return_type => return_type
-      )
-
-      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
-      if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#stop_sandbox\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
-      end
-      return data, status_code, headers
-    end
-
-    # Update sandbox last activity
     # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [nil]
-    def update_last_activity(sandbox_id, opts = {})
-      update_last_activity_with_http_info(sandbox_id, opts)
+    def stop_sandbox(sandbox_id, opts = {})
+      stop_sandbox_with_http_info(sandbox_id, opts)
       nil
     end
 
-    # Update sandbox last activity
+    # Stop sandbox
     # @param sandbox_id [String] ID of the sandbox
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
     # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def update_last_activity_with_http_info(sandbox_id, opts = {})
+    def stop_sandbox_with_http_info(sandbox_id, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: SandboxApi.update_last_activity ...'
+        @api_client.config.logger.debug 'Calling API: SandboxApi.stop_sandbox ...'
       end
       # verify the required parameter 'sandbox_id' is set
       if @api_client.config.client_side_validation && sandbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.update_last_activity"
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.stop_sandbox"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxId}/last-activity'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
+      local_var_path = '/sandbox/{sandboxId}/stop'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -2121,7 +1348,7 @@ module DaytonaApiClient
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
 
       new_options = opts.merge(
-        :operation => :"SandboxApi.update_last_activity",
+        :operation => :"SandboxApi.stop_sandbox",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -2132,50 +1359,48 @@ module DaytonaApiClient
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: SandboxApi#update_last_activity\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: SandboxApi#stop_sandbox\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
     # Update public status
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param is_public [Boolean] Public status to set
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Sandbox]
-    def update_public_status(sandbox_id_or_name, is_public, opts = {})
-      data, _status_code, _headers = update_public_status_with_http_info(sandbox_id_or_name, is_public, opts)
-      data
+    # @return [nil]
+    def update_public_status(sandbox_id, is_public, opts = {})
+      update_public_status_with_http_info(sandbox_id, is_public, opts)
+      nil
     end
 
     # Update public status
-    # @param sandbox_id_or_name [String] ID or name of the sandbox
+    # @param sandbox_id [String] ID of the sandbox
     # @param is_public [Boolean] Public status to set
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_daytona_organization_id Use with JWT to specify the organization ID
-    # @return [Array<(Sandbox, Integer, Hash)>] Sandbox data, response status code and response headers
-    def update_public_status_with_http_info(sandbox_id_or_name, is_public, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def update_public_status_with_http_info(sandbox_id, is_public, opts = {})
       if @api_client.config.debugging
         @api_client.config.logger.debug 'Calling API: SandboxApi.update_public_status ...'
       end
-      # verify the required parameter 'sandbox_id_or_name' is set
-      if @api_client.config.client_side_validation && sandbox_id_or_name.nil?
-        fail ArgumentError, "Missing the required parameter 'sandbox_id_or_name' when calling SandboxApi.update_public_status"
+      # verify the required parameter 'sandbox_id' is set
+      if @api_client.config.client_side_validation && sandbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'sandbox_id' when calling SandboxApi.update_public_status"
       end
       # verify the required parameter 'is_public' is set
       if @api_client.config.client_side_validation && is_public.nil?
         fail ArgumentError, "Missing the required parameter 'is_public' when calling SandboxApi.update_public_status"
       end
       # resource path
-      local_var_path = '/sandbox/{sandboxIdOrName}/public/{isPublic}'.sub('{' + 'sandboxIdOrName' + '}', CGI.escape(sandbox_id_or_name.to_s)).sub('{' + 'isPublic' + '}', CGI.escape(is_public.to_s))
+      local_var_path = '/sandbox/{sandboxId}/public/{isPublic}'.sub('{' + 'sandboxId' + '}', CGI.escape(sandbox_id.to_s)).sub('{' + 'isPublic' + '}', CGI.escape(is_public.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
 
       # header parameters
       header_params = opts[:header_params] || {}
-      # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?
 
       # form parameters
@@ -2185,7 +1410,7 @@ module DaytonaApiClient
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Sandbox'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearer', 'oauth2']
@@ -2247,7 +1472,7 @@ module DaytonaApiClient
       # HTTP header 'Content-Type'
       content_type = @api_client.select_header_content_type(['application/json'])
       if !content_type.nil?
-          header_params['Content-Type'] = content_type
+        header_params['Content-Type'] = content_type
       end
       header_params[:'X-Daytona-Organization-ID'] = opts[:'x_daytona_organization_id'] if !opts[:'x_daytona_organization_id'].nil?