1  // Package execd provides primitives to interact with the openapi HTTP API.
   2  //
   3  // Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.6.0 DO NOT EDIT.
   4  package execd
   5  
   6  import (
   7  	"bytes"
   8  	"context"
   9  	"encoding/json"
  10  	"fmt"
  11  	"io"
  12  	"net/http"
  13  	"net/url"
  14  	"strings"
  15  	"time"
  16  
  17  	"github.com/oapi-codegen/runtime"
  18  	openapi_types "github.com/oapi-codegen/runtime/types"
  19  )
  20  
  21  const (
  22  	AccessTokenScopes = "AccessToken.Scopes"
  23  )
  24  
  25  // Defines values for ServerStreamEventType.
  26  const (
  27  	Error             ServerStreamEventType = "error"
  28  	ExecutionComplete ServerStreamEventType = "execution_complete"
  29  	ExecutionCount    ServerStreamEventType = "execution_count"
  30  	Init              ServerStreamEventType = "init"
  31  	Ping              ServerStreamEventType = "ping"
  32  	Result            ServerStreamEventType = "result"
  33  	Status            ServerStreamEventType = "status"
  34  	Stderr            ServerStreamEventType = "stderr"
  35  	Stdout            ServerStreamEventType = "stdout"
  36  )
  37  
  38  // Valid indicates whether the value is a known member of the ServerStreamEventType enum.
  39  func (e ServerStreamEventType) Valid() bool {
  40  	switch e {
  41  	case Error:
  42  		return true
  43  	case ExecutionComplete:
  44  		return true
  45  	case ExecutionCount:
  46  		return true
  47  	case Init:
  48  		return true
  49  	case Ping:
  50  		return true
  51  	case Result:
  52  		return true
  53  	case Status:
  54  		return true
  55  	case Stderr:
  56  		return true
  57  	case Stdout:
  58  		return true
  59  	default:
  60  		return false
  61  	}
  62  }
  63  
  64  // CodeContext Code execution context with session identifier
  65  type CodeContext struct {
  66  	// ID Unique session identifier returned by CreateContext
  67  	ID *string `json:"id,omitempty"`
  68  
  69  	// Language Execution runtime
  70  	Language string `json:"language"`
  71  }
  72  
  73  // CodeContextRequest Request to create a code execution context
  74  type CodeContextRequest struct {
  75  	// Language Execution runtime (python, bash, java, etc.)
  76  	Language *string `json:"language,omitempty"`
  77  }
  78  
  79  // CommandStatusResponse Command execution status (foreground or background)
  80  type CommandStatusResponse struct {
  81  	// Content Original command content
  82  	Content *string `json:"content,omitempty"`
  83  
  84  	// Error Error message if the command failed
  85  	Error *string `json:"error,omitempty"`
  86  
  87  	// ExitCode Exit code if the command has finished
  88  	ExitCode *int32 `json:"exit_code,omitempty"`
  89  
  90  	// FinishedAt Finish time in RFC3339 format (null if still running)
  91  	FinishedAt *time.Time `json:"finished_at,omitempty"`
  92  
  93  	// ID Command ID returned by RunCommand
  94  	ID *string `json:"id,omitempty"`
  95  
  96  	// Running Whether the command is still running
  97  	Running *bool `json:"running,omitempty"`
  98  
  99  	// StartedAt Start time in RFC3339 format
 100  	StartedAt *time.Time `json:"started_at,omitempty"`
 101  }
 102  
 103  // CreateSessionRequest Request to create a bash session (optional body; empty treated as defaults)
 104  type CreateSessionRequest struct {
 105  	// Cwd Working directory for the session (optional)
 106  	Cwd *string `json:"cwd,omitempty"`
 107  }
 108  
 109  // ErrorResponse Standard error response format
 110  type ErrorResponse struct {
 111  	// Code Error code for programmatic handling
 112  	Code string `json:"code"`
 113  
 114  	// Message Human-readable error message
 115  	Message string `json:"message"`
 116  }
 117  
 118  // FileInfo File metadata including path and permissions
 119  type FileInfo struct {
 120  	// CreatedAt File creation time
 121  	CreatedAt time.Time `json:"created_at"`
 122  
 123  	// Group File group name
 124  	Group string `json:"group"`
 125  
 126  	// Mode File permissions in octal format
 127  	Mode int `json:"mode"`
 128  
 129  	// ModifiedAt Last modification time
 130  	ModifiedAt time.Time `json:"modified_at"`
 131  
 132  	// Owner File owner username
 133  	Owner string `json:"owner"`
 134  
 135  	// Path Absolute file path
 136  	Path string `json:"path"`
 137  
 138  	// Size File size in bytes
 139  	Size int64 `json:"size"`
 140  }
 141  
 142  // Metrics System resource usage metrics
 143  type Metrics struct {
 144  	// CPUCount Number of CPU cores
 145  	CPUCount float32 `json:"cpu_count"`
 146  
 147  	// CPUUsedPct CPU usage percentage
 148  	CPUUsedPct float32 `json:"cpu_used_pct"`
 149  
 150  	// MemTotalMib Total memory in MiB
 151  	MemTotalMib float32 `json:"mem_total_mib"`
 152  
 153  	// MemUsedMib Used memory in MiB
 154  	MemUsedMib float32 `json:"mem_used_mib"`
 155  
 156  	// Timestamp Timestamp when metrics were collected (Unix milliseconds)
 157  	Timestamp int64 `json:"timestamp"`
 158  }
 159  
 160  // Permission File ownership and mode settings
 161  type Permission struct {
 162  	// Group Group name
 163  	Group *string `json:"group,omitempty"`
 164  
 165  	// Mode Permission mode in octal format (e.g., 644, 755)
 166  	Mode int `json:"mode"`
 167  
 168  	// Owner Owner username
 169  	Owner *string `json:"owner,omitempty"`
 170  }
 171  
 172  // RenameFileItem File rename/move operation
 173  type RenameFileItem struct {
 174  	// Dest Destination file path
 175  	Dest string `json:"dest"`
 176  
 177  	// Src Source file path
 178  	Src string `json:"src"`
 179  }
 180  
 181  // ReplaceFileContentItem Content replacement operation
 182  type ReplaceFileContentItem struct {
 183  	// New Replacement string
 184  	New string `json:"new"`
 185  
 186  	// Old String to be replaced
 187  	Old string `json:"old"`
 188  }
 189  
 190  // RunCodeRequest Request to execute code in a context
 191  type RunCodeRequest struct {
 192  	// Code Source code to execute
 193  	Code string `json:"code"`
 194  
 195  	// Context Code execution context with session identifier
 196  	Context *CodeContext `json:"context,omitempty"`
 197  }
 198  
 199  // RunCommandRequest Request to execute a shell command
 200  type RunCommandRequest struct {
 201  	// Background Whether to run command in detached mode
 202  	Background *bool `json:"background,omitempty"`
 203  
 204  	// Command Shell command to execute
 205  	Command string `json:"command"`
 206  
 207  	// Cwd Working directory for command execution
 208  	Cwd *string `json:"cwd,omitempty"`
 209  
 210  	// Envs Environment variables injected into the command process.
 211  	Envs *map[string]string `json:"envs,omitempty"`
 212  
 213  	// GID Unix group ID used to run the command. Requires `uid` to be provided.
 214  	GID *int32 `json:"gid,omitempty"`
 215  
 216  	// Timeout Maximum allowed execution time in milliseconds before the command is forcefully terminated by the server. If omitted, the server will not enforce any timeout.
 217  	Timeout *int64 `json:"timeout,omitempty"`
 218  
 219  	// UID Unix user ID used to run the command. If `gid` is provided, `uid` is required.
 220  	UID *int32 `json:"uid,omitempty"`
 221  }
 222  
 223  // RunInSessionRequest Request to run a command in an existing bash session
 224  type RunInSessionRequest struct {
 225  	// Command Shell command to execute in the session
 226  	Command string `json:"command"`
 227  
 228  	// Cwd Working directory override for this run (optional)
 229  	Cwd *string `json:"cwd,omitempty"`
 230  
 231  	// Timeout Maximum execution time in milliseconds (optional; server may not enforce if omitted)
 232  	Timeout *int64 `json:"timeout,omitempty"`
 233  }
 234  
 235  // ServerStreamEvent Server-sent event for streaming execution output
 236  type ServerStreamEvent struct {
 237  	// Error Execution error details if an error occurred
 238  	Error *struct {
 239  		// Ename Error name/type
 240  		Ename *string `json:"ename,omitempty"`
 241  
 242  		// Evalue Error value/message
 243  		Evalue *string `json:"evalue,omitempty"`
 244  
 245  		// Traceback Stack trace lines
 246  		Traceback *[]string `json:"traceback,omitempty"`
 247  	} `json:"error,omitempty"`
 248  
 249  	// ExecutionCount Cell execution number in the session
 250  	ExecutionCount *int `json:"execution_count,omitempty"`
 251  
 252  	// ExecutionTime Execution duration in milliseconds
 253  	ExecutionTime *int64 `json:"execution_time,omitempty"`
 254  
 255  	// Results Execution output in various MIME types (e.g., "text/plain", "text/html")
 256  	Results *map[string]interface{} `json:"results,omitempty"`
 257  
 258  	// Text Textual data for status, init, and stream events
 259  	Text *string `json:"text,omitempty"`
 260  
 261  	// Timestamp When the event was generated (Unix milliseconds)
 262  	Timestamp *int64 `json:"timestamp,omitempty"`
 263  
 264  	// Type Event type for client-side handling
 265  	Type *ServerStreamEventType `json:"type,omitempty"`
 266  }
 267  
 268  // ServerStreamEventType Event type for client-side handling
 269  type ServerStreamEventType string
 270  
 271  // SessionCreated Response for create_session
 272  type SessionCreated struct {
 273  	// SessionID Unique session ID for run_in_session and delete_session
 274  	SessionID string `json:"session_id"`
 275  }
 276  
 277  // BadRequest Standard error response format
 278  type BadRequest = ErrorResponse
 279  
 280  // InternalServerError Standard error response format
 281  type InternalServerError = ErrorResponse
 282  
 283  // NotFound Standard error response format
 284  type NotFound = ErrorResponse
 285  
 286  // InterruptCodeParams defines parameters for InterruptCode.
 287  type InterruptCodeParams struct {
 288  	// ID Session ID of the execution context to interrupt
 289  	ID string `form:"id" json:"id"`
 290  }
 291  
 292  // DeleteContextsByLanguageParams defines parameters for DeleteContextsByLanguage.
 293  type DeleteContextsByLanguageParams struct {
 294  	// Language Target execution runtime whose contexts should be deleted
 295  	Language string `form:"language" json:"language"`
 296  }
 297  
 298  // ListContextsParams defines parameters for ListContexts.
 299  type ListContextsParams struct {
 300  	// Language Filter contexts by execution runtime (python, bash, java, etc.)
 301  	Language string `form:"language" json:"language"`
 302  }
 303  
 304  // InterruptCommandParams defines parameters for InterruptCommand.
 305  type InterruptCommandParams struct {
 306  	// ID Session ID of the execution context to interrupt
 307  	ID string `form:"id" json:"id"`
 308  }
 309  
 310  // GetBackgroundCommandLogsParams defines parameters for GetBackgroundCommandLogs.
 311  type GetBackgroundCommandLogsParams struct {
 312  	// Cursor Optional 0-based line cursor (behaves like a file seek). When provided, only
 313  	// stdout/stderr lines after this line are returned. The response includes the
 314  	// latest line index (`cursor`) so the client can request incremental output
 315  	// on subsequent calls. If omitted, the full log is returned.
 316  	Cursor *int64 `form:"cursor,omitempty" json:"cursor,omitempty"`
 317  }
 318  
 319  // RemoveDirsParams defines parameters for RemoveDirs.
 320  type RemoveDirsParams struct {
 321  	// Path Directory path(s) to delete (can be specified multiple times)
 322  	Path []string `form:"path" json:"path"`
 323  }
 324  
 325  // MakeDirsJSONBody defines parameters for MakeDirs.
 326  type MakeDirsJSONBody map[string]Permission
 327  
 328  // RemoveFilesParams defines parameters for RemoveFiles.
 329  type RemoveFilesParams struct {
 330  	// Path File path(s) to delete (can be specified multiple times)
 331  	Path []string `form:"path" json:"path"`
 332  }
 333  
 334  // DownloadFileParams defines parameters for DownloadFile.
 335  type DownloadFileParams struct {
 336  	// Path Absolute or relative path of the file to download
 337  	Path string `form:"path" json:"path"`
 338  
 339  	// Range HTTP Range header for partial content requests
 340  	Range *string `json:"Range,omitempty"`
 341  }
 342  
 343  // GetFilesInfoParams defines parameters for GetFilesInfo.
 344  type GetFilesInfoParams struct {
 345  	// Path File path(s) to get info for (can be specified multiple times)
 346  	Path []string `form:"path" json:"path"`
 347  }
 348  
 349  // RenameFilesJSONBody defines parameters for RenameFiles.
 350  type RenameFilesJSONBody = []RenameFileItem
 351  
 352  // ChmodFilesJSONBody defines parameters for ChmodFiles.
 353  type ChmodFilesJSONBody map[string]Permission
 354  
 355  // ReplaceContentJSONBody defines parameters for ReplaceContent.
 356  type ReplaceContentJSONBody map[string]ReplaceFileContentItem
 357  
 358  // SearchFilesParams defines parameters for SearchFiles.
 359  type SearchFilesParams struct {
 360  	// Path Root directory path to search in
 361  	Path string `form:"path" json:"path"`
 362  
 363  	// Pattern Glob pattern to match files (default is **)
 364  	Pattern *string `form:"pattern,omitempty" json:"pattern,omitempty"`
 365  }
 366  
 367  // UploadFileMultipartBody defines parameters for UploadFile.
 368  type UploadFileMultipartBody struct {
 369  	// File File to upload
 370  	File *openapi_types.File `json:"file,omitempty"`
 371  
 372  	// Metadata JSON-encoded file metadata (FileMetadata object)
 373  	Metadata *string `json:"metadata,omitempty"`
 374  }
 375  
 376  // RunCodeJSONRequestBody defines body for RunCode for application/json ContentType.
 377  type RunCodeJSONRequestBody = RunCodeRequest
 378  
 379  // CreateCodeContextJSONRequestBody defines body for CreateCodeContext for application/json ContentType.
 380  type CreateCodeContextJSONRequestBody = CodeContextRequest
 381  
 382  // RunCommandJSONRequestBody defines body for RunCommand for application/json ContentType.
 383  type RunCommandJSONRequestBody = RunCommandRequest
 384  
 385  // MakeDirsJSONRequestBody defines body for MakeDirs for application/json ContentType.
 386  type MakeDirsJSONRequestBody MakeDirsJSONBody
 387  
 388  // RenameFilesJSONRequestBody defines body for RenameFiles for application/json ContentType.
 389  type RenameFilesJSONRequestBody = RenameFilesJSONBody
 390  
 391  // ChmodFilesJSONRequestBody defines body for ChmodFiles for application/json ContentType.
 392  type ChmodFilesJSONRequestBody ChmodFilesJSONBody
 393  
 394  // ReplaceContentJSONRequestBody defines body for ReplaceContent for application/json ContentType.
 395  type ReplaceContentJSONRequestBody ReplaceContentJSONBody
 396  
 397  // UploadFileMultipartRequestBody defines body for UploadFile for multipart/form-data ContentType.
 398  type UploadFileMultipartRequestBody UploadFileMultipartBody
 399  
 400  // CreateSessionJSONRequestBody defines body for CreateSession for application/json ContentType.
 401  type CreateSessionJSONRequestBody = CreateSessionRequest
 402  
 403  // RunInSessionJSONRequestBody defines body for RunInSession for application/json ContentType.
 404  type RunInSessionJSONRequestBody = RunInSessionRequest
 405  
 406  // RequestEditorFn  is the function signature for the RequestEditor callback function
 407  type RequestEditorFn func(ctx context.Context, req *http.Request) error
 408  
 409  // Doer performs HTTP requests.
 410  //
 411  // The standard http.Client implements this interface.
 412  type HttpRequestDoer interface {
 413  	Do(req *http.Request) (*http.Response, error)
 414  }
 415  
 416  // Client which conforms to the OpenAPI3 specification for this service.
 417  type Client struct {
 418  	// The endpoint of the server conforming to this interface, with scheme,
 419  	// https://api.deepmap.com for example. This can contain a path relative
 420  	// to the server, such as https://api.deepmap.com/dev-test, and all the
 421  	// paths in the swagger spec will be appended to the server.
 422  	Server string
 423  
 424  	// Doer for performing requests, typically a *http.Client with any
 425  	// customized settings, such as certificate chains.
 426  	Client HttpRequestDoer
 427  
 428  	// A list of callbacks for modifying requests which are generated before sending over
 429  	// the network.
 430  	RequestEditors []RequestEditorFn
 431  }
 432  
 433  // ClientOption allows setting custom parameters during construction
 434  type ClientOption func(*Client) error
 435  
 436  // Creates a new Client, with reasonable defaults
 437  func NewClient(server string, opts ...ClientOption) (*Client, error) {
 438  	// create a client with sane default values
 439  	client := Client{
 440  		Server: server,
 441  	}
 442  	// mutate client and add all optional params
 443  	for _, o := range opts {
 444  		if err := o(&client); err != nil {
 445  			return nil, err
 446  		}
 447  	}
 448  	// ensure the server URL always has a trailing slash
 449  	if !strings.HasSuffix(client.Server, "/") {
 450  		client.Server += "/"
 451  	}
 452  	// create httpClient, if not already present
 453  	if client.Client == nil {
 454  		client.Client = &http.Client{}
 455  	}
 456  	return &client, nil
 457  }
 458  
 459  // WithHTTPClient allows overriding the default Doer, which is
 460  // automatically created using http.Client. This is useful for tests.
 461  func WithHTTPClient(doer HttpRequestDoer) ClientOption {
 462  	return func(c *Client) error {
 463  		c.Client = doer
 464  		return nil
 465  	}
 466  }
 467  
 468  // WithRequestEditorFn allows setting up a callback function, which will be
 469  // called right before sending the request. This can be used to mutate the request.
 470  func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
 471  	return func(c *Client) error {
 472  		c.RequestEditors = append(c.RequestEditors, fn)
 473  		return nil
 474  	}
 475  }
 476  
 477  // The interface specification for the client above.
 478  type ClientInterface interface {
 479  	// InterruptCode request
 480  	InterruptCode(ctx context.Context, params *InterruptCodeParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 481  
 482  	// RunCodeWithBody request with any body
 483  	RunCodeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 484  
 485  	RunCode(ctx context.Context, body RunCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 486  
 487  	// CreateCodeContextWithBody request with any body
 488  	CreateCodeContextWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 489  
 490  	CreateCodeContext(ctx context.Context, body CreateCodeContextJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 491  
 492  	// DeleteContextsByLanguage request
 493  	DeleteContextsByLanguage(ctx context.Context, params *DeleteContextsByLanguageParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 494  
 495  	// ListContexts request
 496  	ListContexts(ctx context.Context, params *ListContextsParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 497  
 498  	// DeleteContext request
 499  	DeleteContext(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*http.Response, error)
 500  
 501  	// GetContext request
 502  	GetContext(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*http.Response, error)
 503  
 504  	// InterruptCommand request
 505  	InterruptCommand(ctx context.Context, params *InterruptCommandParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 506  
 507  	// RunCommandWithBody request with any body
 508  	RunCommandWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 509  
 510  	RunCommand(ctx context.Context, body RunCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 511  
 512  	// GetCommandStatus request
 513  	GetCommandStatus(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*http.Response, error)
 514  
 515  	// GetBackgroundCommandLogs request
 516  	GetBackgroundCommandLogs(ctx context.Context, id string, params *GetBackgroundCommandLogsParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 517  
 518  	// RemoveDirs request
 519  	RemoveDirs(ctx context.Context, params *RemoveDirsParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 520  
 521  	// MakeDirsWithBody request with any body
 522  	MakeDirsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 523  
 524  	MakeDirs(ctx context.Context, body MakeDirsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 525  
 526  	// RemoveFiles request
 527  	RemoveFiles(ctx context.Context, params *RemoveFilesParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 528  
 529  	// DownloadFile request
 530  	DownloadFile(ctx context.Context, params *DownloadFileParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 531  
 532  	// GetFilesInfo request
 533  	GetFilesInfo(ctx context.Context, params *GetFilesInfoParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 534  
 535  	// RenameFilesWithBody request with any body
 536  	RenameFilesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 537  
 538  	RenameFiles(ctx context.Context, body RenameFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 539  
 540  	// ChmodFilesWithBody request with any body
 541  	ChmodFilesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 542  
 543  	ChmodFiles(ctx context.Context, body ChmodFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 544  
 545  	// ReplaceContentWithBody request with any body
 546  	ReplaceContentWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 547  
 548  	ReplaceContent(ctx context.Context, body ReplaceContentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 549  
 550  	// SearchFiles request
 551  	SearchFiles(ctx context.Context, params *SearchFilesParams, reqEditors ...RequestEditorFn) (*http.Response, error)
 552  
 553  	// UploadFileWithBody request with any body
 554  	UploadFileWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 555  
 556  	// GetMetrics request
 557  	GetMetrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
 558  
 559  	// WatchMetrics request
 560  	WatchMetrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
 561  
 562  	// Ping request
 563  	Ping(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)
 564  
 565  	// CreateSessionWithBody request with any body
 566  	CreateSessionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 567  
 568  	CreateSession(ctx context.Context, body CreateSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 569  
 570  	// DeleteSession request
 571  	DeleteSession(ctx context.Context, sessionID string, reqEditors ...RequestEditorFn) (*http.Response, error)
 572  
 573  	// RunInSessionWithBody request with any body
 574  	RunInSessionWithBody(ctx context.Context, sessionID string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)
 575  
 576  	RunInSession(ctx context.Context, sessionID string, body RunInSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
 577  }
 578  
 579  func (c *Client) InterruptCode(ctx context.Context, params *InterruptCodeParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 580  	req, err := NewInterruptCodeRequest(c.Server, params)
 581  	if err != nil {
 582  		return nil, err
 583  	}
 584  	req = req.WithContext(ctx)
 585  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 586  		return nil, err
 587  	}
 588  	return c.Client.Do(req)
 589  }
 590  
 591  func (c *Client) RunCodeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 592  	req, err := NewRunCodeRequestWithBody(c.Server, contentType, body)
 593  	if err != nil {
 594  		return nil, err
 595  	}
 596  	req = req.WithContext(ctx)
 597  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 598  		return nil, err
 599  	}
 600  	return c.Client.Do(req)
 601  }
 602  
 603  func (c *Client) RunCode(ctx context.Context, body RunCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 604  	req, err := NewRunCodeRequest(c.Server, body)
 605  	if err != nil {
 606  		return nil, err
 607  	}
 608  	req = req.WithContext(ctx)
 609  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 610  		return nil, err
 611  	}
 612  	return c.Client.Do(req)
 613  }
 614  
 615  func (c *Client) CreateCodeContextWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 616  	req, err := NewCreateCodeContextRequestWithBody(c.Server, contentType, body)
 617  	if err != nil {
 618  		return nil, err
 619  	}
 620  	req = req.WithContext(ctx)
 621  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 622  		return nil, err
 623  	}
 624  	return c.Client.Do(req)
 625  }
 626  
 627  func (c *Client) CreateCodeContext(ctx context.Context, body CreateCodeContextJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 628  	req, err := NewCreateCodeContextRequest(c.Server, body)
 629  	if err != nil {
 630  		return nil, err
 631  	}
 632  	req = req.WithContext(ctx)
 633  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 634  		return nil, err
 635  	}
 636  	return c.Client.Do(req)
 637  }
 638  
 639  func (c *Client) DeleteContextsByLanguage(ctx context.Context, params *DeleteContextsByLanguageParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 640  	req, err := NewDeleteContextsByLanguageRequest(c.Server, params)
 641  	if err != nil {
 642  		return nil, err
 643  	}
 644  	req = req.WithContext(ctx)
 645  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 646  		return nil, err
 647  	}
 648  	return c.Client.Do(req)
 649  }
 650  
 651  func (c *Client) ListContexts(ctx context.Context, params *ListContextsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 652  	req, err := NewListContextsRequest(c.Server, params)
 653  	if err != nil {
 654  		return nil, err
 655  	}
 656  	req = req.WithContext(ctx)
 657  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 658  		return nil, err
 659  	}
 660  	return c.Client.Do(req)
 661  }
 662  
 663  func (c *Client) DeleteContext(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*http.Response, error) {
 664  	req, err := NewDeleteContextRequest(c.Server, contextID)
 665  	if err != nil {
 666  		return nil, err
 667  	}
 668  	req = req.WithContext(ctx)
 669  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 670  		return nil, err
 671  	}
 672  	return c.Client.Do(req)
 673  }
 674  
 675  func (c *Client) GetContext(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*http.Response, error) {
 676  	req, err := NewGetContextRequest(c.Server, contextID)
 677  	if err != nil {
 678  		return nil, err
 679  	}
 680  	req = req.WithContext(ctx)
 681  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 682  		return nil, err
 683  	}
 684  	return c.Client.Do(req)
 685  }
 686  
 687  func (c *Client) InterruptCommand(ctx context.Context, params *InterruptCommandParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 688  	req, err := NewInterruptCommandRequest(c.Server, params)
 689  	if err != nil {
 690  		return nil, err
 691  	}
 692  	req = req.WithContext(ctx)
 693  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 694  		return nil, err
 695  	}
 696  	return c.Client.Do(req)
 697  }
 698  
 699  func (c *Client) RunCommandWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 700  	req, err := NewRunCommandRequestWithBody(c.Server, contentType, body)
 701  	if err != nil {
 702  		return nil, err
 703  	}
 704  	req = req.WithContext(ctx)
 705  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 706  		return nil, err
 707  	}
 708  	return c.Client.Do(req)
 709  }
 710  
 711  func (c *Client) RunCommand(ctx context.Context, body RunCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 712  	req, err := NewRunCommandRequest(c.Server, body)
 713  	if err != nil {
 714  		return nil, err
 715  	}
 716  	req = req.WithContext(ctx)
 717  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 718  		return nil, err
 719  	}
 720  	return c.Client.Do(req)
 721  }
 722  
 723  func (c *Client) GetCommandStatus(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*http.Response, error) {
 724  	req, err := NewGetCommandStatusRequest(c.Server, id)
 725  	if err != nil {
 726  		return nil, err
 727  	}
 728  	req = req.WithContext(ctx)
 729  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 730  		return nil, err
 731  	}
 732  	return c.Client.Do(req)
 733  }
 734  
 735  func (c *Client) GetBackgroundCommandLogs(ctx context.Context, id string, params *GetBackgroundCommandLogsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 736  	req, err := NewGetBackgroundCommandLogsRequest(c.Server, id, params)
 737  	if err != nil {
 738  		return nil, err
 739  	}
 740  	req = req.WithContext(ctx)
 741  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 742  		return nil, err
 743  	}
 744  	return c.Client.Do(req)
 745  }
 746  
 747  func (c *Client) RemoveDirs(ctx context.Context, params *RemoveDirsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 748  	req, err := NewRemoveDirsRequest(c.Server, params)
 749  	if err != nil {
 750  		return nil, err
 751  	}
 752  	req = req.WithContext(ctx)
 753  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 754  		return nil, err
 755  	}
 756  	return c.Client.Do(req)
 757  }
 758  
 759  func (c *Client) MakeDirsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 760  	req, err := NewMakeDirsRequestWithBody(c.Server, contentType, body)
 761  	if err != nil {
 762  		return nil, err
 763  	}
 764  	req = req.WithContext(ctx)
 765  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 766  		return nil, err
 767  	}
 768  	return c.Client.Do(req)
 769  }
 770  
 771  func (c *Client) MakeDirs(ctx context.Context, body MakeDirsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 772  	req, err := NewMakeDirsRequest(c.Server, body)
 773  	if err != nil {
 774  		return nil, err
 775  	}
 776  	req = req.WithContext(ctx)
 777  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 778  		return nil, err
 779  	}
 780  	return c.Client.Do(req)
 781  }
 782  
 783  func (c *Client) RemoveFiles(ctx context.Context, params *RemoveFilesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 784  	req, err := NewRemoveFilesRequest(c.Server, params)
 785  	if err != nil {
 786  		return nil, err
 787  	}
 788  	req = req.WithContext(ctx)
 789  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 790  		return nil, err
 791  	}
 792  	return c.Client.Do(req)
 793  }
 794  
 795  func (c *Client) DownloadFile(ctx context.Context, params *DownloadFileParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 796  	req, err := NewDownloadFileRequest(c.Server, params)
 797  	if err != nil {
 798  		return nil, err
 799  	}
 800  	req = req.WithContext(ctx)
 801  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 802  		return nil, err
 803  	}
 804  	return c.Client.Do(req)
 805  }
 806  
 807  func (c *Client) GetFilesInfo(ctx context.Context, params *GetFilesInfoParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 808  	req, err := NewGetFilesInfoRequest(c.Server, params)
 809  	if err != nil {
 810  		return nil, err
 811  	}
 812  	req = req.WithContext(ctx)
 813  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 814  		return nil, err
 815  	}
 816  	return c.Client.Do(req)
 817  }
 818  
 819  func (c *Client) RenameFilesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 820  	req, err := NewRenameFilesRequestWithBody(c.Server, contentType, body)
 821  	if err != nil {
 822  		return nil, err
 823  	}
 824  	req = req.WithContext(ctx)
 825  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 826  		return nil, err
 827  	}
 828  	return c.Client.Do(req)
 829  }
 830  
 831  func (c *Client) RenameFiles(ctx context.Context, body RenameFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 832  	req, err := NewRenameFilesRequest(c.Server, body)
 833  	if err != nil {
 834  		return nil, err
 835  	}
 836  	req = req.WithContext(ctx)
 837  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 838  		return nil, err
 839  	}
 840  	return c.Client.Do(req)
 841  }
 842  
 843  func (c *Client) ChmodFilesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 844  	req, err := NewChmodFilesRequestWithBody(c.Server, contentType, body)
 845  	if err != nil {
 846  		return nil, err
 847  	}
 848  	req = req.WithContext(ctx)
 849  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 850  		return nil, err
 851  	}
 852  	return c.Client.Do(req)
 853  }
 854  
 855  func (c *Client) ChmodFiles(ctx context.Context, body ChmodFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 856  	req, err := NewChmodFilesRequest(c.Server, body)
 857  	if err != nil {
 858  		return nil, err
 859  	}
 860  	req = req.WithContext(ctx)
 861  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 862  		return nil, err
 863  	}
 864  	return c.Client.Do(req)
 865  }
 866  
 867  func (c *Client) ReplaceContentWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 868  	req, err := NewReplaceContentRequestWithBody(c.Server, contentType, body)
 869  	if err != nil {
 870  		return nil, err
 871  	}
 872  	req = req.WithContext(ctx)
 873  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 874  		return nil, err
 875  	}
 876  	return c.Client.Do(req)
 877  }
 878  
 879  func (c *Client) ReplaceContent(ctx context.Context, body ReplaceContentJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 880  	req, err := NewReplaceContentRequest(c.Server, body)
 881  	if err != nil {
 882  		return nil, err
 883  	}
 884  	req = req.WithContext(ctx)
 885  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 886  		return nil, err
 887  	}
 888  	return c.Client.Do(req)
 889  }
 890  
 891  func (c *Client) SearchFiles(ctx context.Context, params *SearchFilesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
 892  	req, err := NewSearchFilesRequest(c.Server, params)
 893  	if err != nil {
 894  		return nil, err
 895  	}
 896  	req = req.WithContext(ctx)
 897  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 898  		return nil, err
 899  	}
 900  	return c.Client.Do(req)
 901  }
 902  
 903  func (c *Client) UploadFileWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 904  	req, err := NewUploadFileRequestWithBody(c.Server, contentType, body)
 905  	if err != nil {
 906  		return nil, err
 907  	}
 908  	req = req.WithContext(ctx)
 909  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 910  		return nil, err
 911  	}
 912  	return c.Client.Do(req)
 913  }
 914  
 915  func (c *Client) GetMetrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
 916  	req, err := NewGetMetricsRequest(c.Server)
 917  	if err != nil {
 918  		return nil, err
 919  	}
 920  	req = req.WithContext(ctx)
 921  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 922  		return nil, err
 923  	}
 924  	return c.Client.Do(req)
 925  }
 926  
 927  func (c *Client) WatchMetrics(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
 928  	req, err := NewWatchMetricsRequest(c.Server)
 929  	if err != nil {
 930  		return nil, err
 931  	}
 932  	req = req.WithContext(ctx)
 933  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 934  		return nil, err
 935  	}
 936  	return c.Client.Do(req)
 937  }
 938  
 939  func (c *Client) Ping(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
 940  	req, err := NewPingRequest(c.Server)
 941  	if err != nil {
 942  		return nil, err
 943  	}
 944  	req = req.WithContext(ctx)
 945  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 946  		return nil, err
 947  	}
 948  	return c.Client.Do(req)
 949  }
 950  
 951  func (c *Client) CreateSessionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 952  	req, err := NewCreateSessionRequestWithBody(c.Server, contentType, body)
 953  	if err != nil {
 954  		return nil, err
 955  	}
 956  	req = req.WithContext(ctx)
 957  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 958  		return nil, err
 959  	}
 960  	return c.Client.Do(req)
 961  }
 962  
 963  func (c *Client) CreateSession(ctx context.Context, body CreateSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
 964  	req, err := NewCreateSessionRequest(c.Server, body)
 965  	if err != nil {
 966  		return nil, err
 967  	}
 968  	req = req.WithContext(ctx)
 969  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 970  		return nil, err
 971  	}
 972  	return c.Client.Do(req)
 973  }
 974  
 975  func (c *Client) DeleteSession(ctx context.Context, sessionID string, reqEditors ...RequestEditorFn) (*http.Response, error) {
 976  	req, err := NewDeleteSessionRequest(c.Server, sessionID)
 977  	if err != nil {
 978  		return nil, err
 979  	}
 980  	req = req.WithContext(ctx)
 981  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 982  		return nil, err
 983  	}
 984  	return c.Client.Do(req)
 985  }
 986  
 987  func (c *Client) RunInSessionWithBody(ctx context.Context, sessionID string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
 988  	req, err := NewRunInSessionRequestWithBody(c.Server, sessionID, contentType, body)
 989  	if err != nil {
 990  		return nil, err
 991  	}
 992  	req = req.WithContext(ctx)
 993  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 994  		return nil, err
 995  	}
 996  	return c.Client.Do(req)
 997  }
 998  
 999  func (c *Client) RunInSession(ctx context.Context, sessionID string, body RunInSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
1000  	req, err := NewRunInSessionRequest(c.Server, sessionID, body)
1001  	if err != nil {
1002  		return nil, err
1003  	}
1004  	req = req.WithContext(ctx)
1005  	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
1006  		return nil, err
1007  	}
1008  	return c.Client.Do(req)
1009  }
1010  
1011  // NewInterruptCodeRequest generates requests for InterruptCode
1012  func NewInterruptCodeRequest(server string, params *InterruptCodeParams) (*http.Request, error) {
1013  	var err error
1014  
1015  	serverURL, err := url.Parse(server)
1016  	if err != nil {
1017  		return nil, err
1018  	}
1019  
1020  	operationPath := fmt.Sprintf("/code")
1021  	if operationPath[0] == '/' {
1022  		operationPath = "." + operationPath
1023  	}
1024  
1025  	queryURL, err := serverURL.Parse(operationPath)
1026  	if err != nil {
1027  		return nil, err
1028  	}
1029  
1030  	if params != nil {
1031  		queryValues := queryURL.Query()
1032  
1033  		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "id", params.ID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1034  			return nil, err
1035  		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1036  			return nil, err
1037  		} else {
1038  			for k, v := range parsed {
1039  				for _, v2 := range v {
1040  					queryValues.Add(k, v2)
1041  				}
1042  			}
1043  		}
1044  
1045  		queryURL.RawQuery = queryValues.Encode()
1046  	}
1047  
1048  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
1049  	if err != nil {
1050  		return nil, err
1051  	}
1052  
1053  	return req, nil
1054  }
1055  
1056  // NewRunCodeRequest calls the generic RunCode builder with application/json body
1057  func NewRunCodeRequest(server string, body RunCodeJSONRequestBody) (*http.Request, error) {
1058  	var bodyReader io.Reader
1059  	buf, err := json.Marshal(body)
1060  	if err != nil {
1061  		return nil, err
1062  	}
1063  	bodyReader = bytes.NewReader(buf)
1064  	return NewRunCodeRequestWithBody(server, "application/json", bodyReader)
1065  }
1066  
1067  // NewRunCodeRequestWithBody generates requests for RunCode with any type of body
1068  func NewRunCodeRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1069  	var err error
1070  
1071  	serverURL, err := url.Parse(server)
1072  	if err != nil {
1073  		return nil, err
1074  	}
1075  
1076  	operationPath := fmt.Sprintf("/code")
1077  	if operationPath[0] == '/' {
1078  		operationPath = "." + operationPath
1079  	}
1080  
1081  	queryURL, err := serverURL.Parse(operationPath)
1082  	if err != nil {
1083  		return nil, err
1084  	}
1085  
1086  	req, err := http.NewRequest("POST", queryURL.String(), body)
1087  	if err != nil {
1088  		return nil, err
1089  	}
1090  
1091  	req.Header.Add("Content-Type", contentType)
1092  
1093  	return req, nil
1094  }
1095  
1096  // NewCreateCodeContextRequest calls the generic CreateCodeContext builder with application/json body
1097  func NewCreateCodeContextRequest(server string, body CreateCodeContextJSONRequestBody) (*http.Request, error) {
1098  	var bodyReader io.Reader
1099  	buf, err := json.Marshal(body)
1100  	if err != nil {
1101  		return nil, err
1102  	}
1103  	bodyReader = bytes.NewReader(buf)
1104  	return NewCreateCodeContextRequestWithBody(server, "application/json", bodyReader)
1105  }
1106  
1107  // NewCreateCodeContextRequestWithBody generates requests for CreateCodeContext with any type of body
1108  func NewCreateCodeContextRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1109  	var err error
1110  
1111  	serverURL, err := url.Parse(server)
1112  	if err != nil {
1113  		return nil, err
1114  	}
1115  
1116  	operationPath := fmt.Sprintf("/code/context")
1117  	if operationPath[0] == '/' {
1118  		operationPath = "." + operationPath
1119  	}
1120  
1121  	queryURL, err := serverURL.Parse(operationPath)
1122  	if err != nil {
1123  		return nil, err
1124  	}
1125  
1126  	req, err := http.NewRequest("POST", queryURL.String(), body)
1127  	if err != nil {
1128  		return nil, err
1129  	}
1130  
1131  	req.Header.Add("Content-Type", contentType)
1132  
1133  	return req, nil
1134  }
1135  
1136  // NewDeleteContextsByLanguageRequest generates requests for DeleteContextsByLanguage
1137  func NewDeleteContextsByLanguageRequest(server string, params *DeleteContextsByLanguageParams) (*http.Request, error) {
1138  	var err error
1139  
1140  	serverURL, err := url.Parse(server)
1141  	if err != nil {
1142  		return nil, err
1143  	}
1144  
1145  	operationPath := fmt.Sprintf("/code/contexts")
1146  	if operationPath[0] == '/' {
1147  		operationPath = "." + operationPath
1148  	}
1149  
1150  	queryURL, err := serverURL.Parse(operationPath)
1151  	if err != nil {
1152  		return nil, err
1153  	}
1154  
1155  	if params != nil {
1156  		queryValues := queryURL.Query()
1157  
1158  		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "language", params.Language, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1159  			return nil, err
1160  		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1161  			return nil, err
1162  		} else {
1163  			for k, v := range parsed {
1164  				for _, v2 := range v {
1165  					queryValues.Add(k, v2)
1166  				}
1167  			}
1168  		}
1169  
1170  		queryURL.RawQuery = queryValues.Encode()
1171  	}
1172  
1173  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
1174  	if err != nil {
1175  		return nil, err
1176  	}
1177  
1178  	return req, nil
1179  }
1180  
1181  // NewListContextsRequest generates requests for ListContexts
1182  func NewListContextsRequest(server string, params *ListContextsParams) (*http.Request, error) {
1183  	var err error
1184  
1185  	serverURL, err := url.Parse(server)
1186  	if err != nil {
1187  		return nil, err
1188  	}
1189  
1190  	operationPath := fmt.Sprintf("/code/contexts")
1191  	if operationPath[0] == '/' {
1192  		operationPath = "." + operationPath
1193  	}
1194  
1195  	queryURL, err := serverURL.Parse(operationPath)
1196  	if err != nil {
1197  		return nil, err
1198  	}
1199  
1200  	if params != nil {
1201  		queryValues := queryURL.Query()
1202  
1203  		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "language", params.Language, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1204  			return nil, err
1205  		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1206  			return nil, err
1207  		} else {
1208  			for k, v := range parsed {
1209  				for _, v2 := range v {
1210  					queryValues.Add(k, v2)
1211  				}
1212  			}
1213  		}
1214  
1215  		queryURL.RawQuery = queryValues.Encode()
1216  	}
1217  
1218  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1219  	if err != nil {
1220  		return nil, err
1221  	}
1222  
1223  	return req, nil
1224  }
1225  
1226  // NewDeleteContextRequest generates requests for DeleteContext
1227  func NewDeleteContextRequest(server string, contextID string) (*http.Request, error) {
1228  	var err error
1229  
1230  	var pathParam0 string
1231  
1232  	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "context_id", contextID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
1233  	if err != nil {
1234  		return nil, err
1235  	}
1236  
1237  	serverURL, err := url.Parse(server)
1238  	if err != nil {
1239  		return nil, err
1240  	}
1241  
1242  	operationPath := fmt.Sprintf("/code/contexts/%s", pathParam0)
1243  	if operationPath[0] == '/' {
1244  		operationPath = "." + operationPath
1245  	}
1246  
1247  	queryURL, err := serverURL.Parse(operationPath)
1248  	if err != nil {
1249  		return nil, err
1250  	}
1251  
1252  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
1253  	if err != nil {
1254  		return nil, err
1255  	}
1256  
1257  	return req, nil
1258  }
1259  
1260  // NewGetContextRequest generates requests for GetContext
1261  func NewGetContextRequest(server string, contextID string) (*http.Request, error) {
1262  	var err error
1263  
1264  	var pathParam0 string
1265  
1266  	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "context_id", contextID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
1267  	if err != nil {
1268  		return nil, err
1269  	}
1270  
1271  	serverURL, err := url.Parse(server)
1272  	if err != nil {
1273  		return nil, err
1274  	}
1275  
1276  	operationPath := fmt.Sprintf("/code/contexts/%s", pathParam0)
1277  	if operationPath[0] == '/' {
1278  		operationPath = "." + operationPath
1279  	}
1280  
1281  	queryURL, err := serverURL.Parse(operationPath)
1282  	if err != nil {
1283  		return nil, err
1284  	}
1285  
1286  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1287  	if err != nil {
1288  		return nil, err
1289  	}
1290  
1291  	return req, nil
1292  }
1293  
1294  // NewInterruptCommandRequest generates requests for InterruptCommand
1295  func NewInterruptCommandRequest(server string, params *InterruptCommandParams) (*http.Request, error) {
1296  	var err error
1297  
1298  	serverURL, err := url.Parse(server)
1299  	if err != nil {
1300  		return nil, err
1301  	}
1302  
1303  	operationPath := fmt.Sprintf("/command")
1304  	if operationPath[0] == '/' {
1305  		operationPath = "." + operationPath
1306  	}
1307  
1308  	queryURL, err := serverURL.Parse(operationPath)
1309  	if err != nil {
1310  		return nil, err
1311  	}
1312  
1313  	if params != nil {
1314  		queryValues := queryURL.Query()
1315  
1316  		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "id", params.ID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1317  			return nil, err
1318  		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1319  			return nil, err
1320  		} else {
1321  			for k, v := range parsed {
1322  				for _, v2 := range v {
1323  					queryValues.Add(k, v2)
1324  				}
1325  			}
1326  		}
1327  
1328  		queryURL.RawQuery = queryValues.Encode()
1329  	}
1330  
1331  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
1332  	if err != nil {
1333  		return nil, err
1334  	}
1335  
1336  	return req, nil
1337  }
1338  
1339  // NewRunCommandRequest calls the generic RunCommand builder with application/json body
1340  func NewRunCommandRequest(server string, body RunCommandJSONRequestBody) (*http.Request, error) {
1341  	var bodyReader io.Reader
1342  	buf, err := json.Marshal(body)
1343  	if err != nil {
1344  		return nil, err
1345  	}
1346  	bodyReader = bytes.NewReader(buf)
1347  	return NewRunCommandRequestWithBody(server, "application/json", bodyReader)
1348  }
1349  
1350  // NewRunCommandRequestWithBody generates requests for RunCommand with any type of body
1351  func NewRunCommandRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1352  	var err error
1353  
1354  	serverURL, err := url.Parse(server)
1355  	if err != nil {
1356  		return nil, err
1357  	}
1358  
1359  	operationPath := fmt.Sprintf("/command")
1360  	if operationPath[0] == '/' {
1361  		operationPath = "." + operationPath
1362  	}
1363  
1364  	queryURL, err := serverURL.Parse(operationPath)
1365  	if err != nil {
1366  		return nil, err
1367  	}
1368  
1369  	req, err := http.NewRequest("POST", queryURL.String(), body)
1370  	if err != nil {
1371  		return nil, err
1372  	}
1373  
1374  	req.Header.Add("Content-Type", contentType)
1375  
1376  	return req, nil
1377  }
1378  
1379  // NewGetCommandStatusRequest generates requests for GetCommandStatus
1380  func NewGetCommandStatusRequest(server string, id string) (*http.Request, error) {
1381  	var err error
1382  
1383  	var pathParam0 string
1384  
1385  	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "id", id, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
1386  	if err != nil {
1387  		return nil, err
1388  	}
1389  
1390  	serverURL, err := url.Parse(server)
1391  	if err != nil {
1392  		return nil, err
1393  	}
1394  
1395  	operationPath := fmt.Sprintf("/command/status/%s", pathParam0)
1396  	if operationPath[0] == '/' {
1397  		operationPath = "." + operationPath
1398  	}
1399  
1400  	queryURL, err := serverURL.Parse(operationPath)
1401  	if err != nil {
1402  		return nil, err
1403  	}
1404  
1405  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1406  	if err != nil {
1407  		return nil, err
1408  	}
1409  
1410  	return req, nil
1411  }
1412  
1413  // NewGetBackgroundCommandLogsRequest generates requests for GetBackgroundCommandLogs
1414  func NewGetBackgroundCommandLogsRequest(server string, id string, params *GetBackgroundCommandLogsParams) (*http.Request, error) {
1415  	var err error
1416  
1417  	var pathParam0 string
1418  
1419  	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "id", id, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
1420  	if err != nil {
1421  		return nil, err
1422  	}
1423  
1424  	serverURL, err := url.Parse(server)
1425  	if err != nil {
1426  		return nil, err
1427  	}
1428  
1429  	operationPath := fmt.Sprintf("/command/%s/logs", pathParam0)
1430  	if operationPath[0] == '/' {
1431  		operationPath = "." + operationPath
1432  	}
1433  
1434  	queryURL, err := serverURL.Parse(operationPath)
1435  	if err != nil {
1436  		return nil, err
1437  	}
1438  
1439  	if params != nil {
1440  		queryValues := queryURL.Query()
1441  
1442  		if params.Cursor != nil {
1443  
1444  			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "cursor", *params.Cursor, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "integer", Format: "int64"}); err != nil {
1445  				return nil, err
1446  			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1447  				return nil, err
1448  			} else {
1449  				for k, v := range parsed {
1450  					for _, v2 := range v {
1451  						queryValues.Add(k, v2)
1452  					}
1453  				}
1454  			}
1455  
1456  		}
1457  
1458  		queryURL.RawQuery = queryValues.Encode()
1459  	}
1460  
1461  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1462  	if err != nil {
1463  		return nil, err
1464  	}
1465  
1466  	return req, nil
1467  }
1468  
1469  // NewRemoveDirsRequest generates requests for RemoveDirs
1470  func NewRemoveDirsRequest(server string, params *RemoveDirsParams) (*http.Request, error) {
1471  	var err error
1472  
1473  	serverURL, err := url.Parse(server)
1474  	if err != nil {
1475  		return nil, err
1476  	}
1477  
1478  	operationPath := fmt.Sprintf("/directories")
1479  	if operationPath[0] == '/' {
1480  		operationPath = "." + operationPath
1481  	}
1482  
1483  	queryURL, err := serverURL.Parse(operationPath)
1484  	if err != nil {
1485  		return nil, err
1486  	}
1487  
1488  	if params != nil {
1489  		queryValues := queryURL.Query()
1490  
1491  		if params.Path != nil {
1492  
1493  			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "path", params.Path, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "array", Format: ""}); err != nil {
1494  				return nil, err
1495  			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1496  				return nil, err
1497  			} else {
1498  				for k, v := range parsed {
1499  					for _, v2 := range v {
1500  						queryValues.Add(k, v2)
1501  					}
1502  				}
1503  			}
1504  
1505  		}
1506  
1507  		queryURL.RawQuery = queryValues.Encode()
1508  	}
1509  
1510  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
1511  	if err != nil {
1512  		return nil, err
1513  	}
1514  
1515  	return req, nil
1516  }
1517  
1518  // NewMakeDirsRequest calls the generic MakeDirs builder with application/json body
1519  func NewMakeDirsRequest(server string, body MakeDirsJSONRequestBody) (*http.Request, error) {
1520  	var bodyReader io.Reader
1521  	buf, err := json.Marshal(body)
1522  	if err != nil {
1523  		return nil, err
1524  	}
1525  	bodyReader = bytes.NewReader(buf)
1526  	return NewMakeDirsRequestWithBody(server, "application/json", bodyReader)
1527  }
1528  
1529  // NewMakeDirsRequestWithBody generates requests for MakeDirs with any type of body
1530  func NewMakeDirsRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1531  	var err error
1532  
1533  	serverURL, err := url.Parse(server)
1534  	if err != nil {
1535  		return nil, err
1536  	}
1537  
1538  	operationPath := fmt.Sprintf("/directories")
1539  	if operationPath[0] == '/' {
1540  		operationPath = "." + operationPath
1541  	}
1542  
1543  	queryURL, err := serverURL.Parse(operationPath)
1544  	if err != nil {
1545  		return nil, err
1546  	}
1547  
1548  	req, err := http.NewRequest("POST", queryURL.String(), body)
1549  	if err != nil {
1550  		return nil, err
1551  	}
1552  
1553  	req.Header.Add("Content-Type", contentType)
1554  
1555  	return req, nil
1556  }
1557  
1558  // NewRemoveFilesRequest generates requests for RemoveFiles
1559  func NewRemoveFilesRequest(server string, params *RemoveFilesParams) (*http.Request, error) {
1560  	var err error
1561  
1562  	serverURL, err := url.Parse(server)
1563  	if err != nil {
1564  		return nil, err
1565  	}
1566  
1567  	operationPath := fmt.Sprintf("/files")
1568  	if operationPath[0] == '/' {
1569  		operationPath = "." + operationPath
1570  	}
1571  
1572  	queryURL, err := serverURL.Parse(operationPath)
1573  	if err != nil {
1574  		return nil, err
1575  	}
1576  
1577  	if params != nil {
1578  		queryValues := queryURL.Query()
1579  
1580  		if params.Path != nil {
1581  
1582  			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "path", params.Path, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "array", Format: ""}); err != nil {
1583  				return nil, err
1584  			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1585  				return nil, err
1586  			} else {
1587  				for k, v := range parsed {
1588  					for _, v2 := range v {
1589  						queryValues.Add(k, v2)
1590  					}
1591  				}
1592  			}
1593  
1594  		}
1595  
1596  		queryURL.RawQuery = queryValues.Encode()
1597  	}
1598  
1599  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
1600  	if err != nil {
1601  		return nil, err
1602  	}
1603  
1604  	return req, nil
1605  }
1606  
1607  // NewDownloadFileRequest generates requests for DownloadFile
1608  func NewDownloadFileRequest(server string, params *DownloadFileParams) (*http.Request, error) {
1609  	var err error
1610  
1611  	serverURL, err := url.Parse(server)
1612  	if err != nil {
1613  		return nil, err
1614  	}
1615  
1616  	operationPath := fmt.Sprintf("/files/download")
1617  	if operationPath[0] == '/' {
1618  		operationPath = "." + operationPath
1619  	}
1620  
1621  	queryURL, err := serverURL.Parse(operationPath)
1622  	if err != nil {
1623  		return nil, err
1624  	}
1625  
1626  	if params != nil {
1627  		queryValues := queryURL.Query()
1628  
1629  		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "path", params.Path, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1630  			return nil, err
1631  		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1632  			return nil, err
1633  		} else {
1634  			for k, v := range parsed {
1635  				for _, v2 := range v {
1636  					queryValues.Add(k, v2)
1637  				}
1638  			}
1639  		}
1640  
1641  		queryURL.RawQuery = queryValues.Encode()
1642  	}
1643  
1644  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1645  	if err != nil {
1646  		return nil, err
1647  	}
1648  
1649  	if params != nil {
1650  
1651  		if params.Range != nil {
1652  			var headerParam0 string
1653  
1654  			headerParam0, err = runtime.StyleParamWithOptions("simple", false, "Range", *params.Range, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationHeader, Type: "string", Format: ""})
1655  			if err != nil {
1656  				return nil, err
1657  			}
1658  
1659  			req.Header.Set("Range", headerParam0)
1660  		}
1661  
1662  	}
1663  
1664  	return req, nil
1665  }
1666  
1667  // NewGetFilesInfoRequest generates requests for GetFilesInfo
1668  func NewGetFilesInfoRequest(server string, params *GetFilesInfoParams) (*http.Request, error) {
1669  	var err error
1670  
1671  	serverURL, err := url.Parse(server)
1672  	if err != nil {
1673  		return nil, err
1674  	}
1675  
1676  	operationPath := fmt.Sprintf("/files/info")
1677  	if operationPath[0] == '/' {
1678  		operationPath = "." + operationPath
1679  	}
1680  
1681  	queryURL, err := serverURL.Parse(operationPath)
1682  	if err != nil {
1683  		return nil, err
1684  	}
1685  
1686  	if params != nil {
1687  		queryValues := queryURL.Query()
1688  
1689  		if params.Path != nil {
1690  
1691  			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "path", params.Path, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "array", Format: ""}); err != nil {
1692  				return nil, err
1693  			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1694  				return nil, err
1695  			} else {
1696  				for k, v := range parsed {
1697  					for _, v2 := range v {
1698  						queryValues.Add(k, v2)
1699  					}
1700  				}
1701  			}
1702  
1703  		}
1704  
1705  		queryURL.RawQuery = queryValues.Encode()
1706  	}
1707  
1708  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1709  	if err != nil {
1710  		return nil, err
1711  	}
1712  
1713  	return req, nil
1714  }
1715  
1716  // NewRenameFilesRequest calls the generic RenameFiles builder with application/json body
1717  func NewRenameFilesRequest(server string, body RenameFilesJSONRequestBody) (*http.Request, error) {
1718  	var bodyReader io.Reader
1719  	buf, err := json.Marshal(body)
1720  	if err != nil {
1721  		return nil, err
1722  	}
1723  	bodyReader = bytes.NewReader(buf)
1724  	return NewRenameFilesRequestWithBody(server, "application/json", bodyReader)
1725  }
1726  
1727  // NewRenameFilesRequestWithBody generates requests for RenameFiles with any type of body
1728  func NewRenameFilesRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1729  	var err error
1730  
1731  	serverURL, err := url.Parse(server)
1732  	if err != nil {
1733  		return nil, err
1734  	}
1735  
1736  	operationPath := fmt.Sprintf("/files/mv")
1737  	if operationPath[0] == '/' {
1738  		operationPath = "." + operationPath
1739  	}
1740  
1741  	queryURL, err := serverURL.Parse(operationPath)
1742  	if err != nil {
1743  		return nil, err
1744  	}
1745  
1746  	req, err := http.NewRequest("POST", queryURL.String(), body)
1747  	if err != nil {
1748  		return nil, err
1749  	}
1750  
1751  	req.Header.Add("Content-Type", contentType)
1752  
1753  	return req, nil
1754  }
1755  
1756  // NewChmodFilesRequest calls the generic ChmodFiles builder with application/json body
1757  func NewChmodFilesRequest(server string, body ChmodFilesJSONRequestBody) (*http.Request, error) {
1758  	var bodyReader io.Reader
1759  	buf, err := json.Marshal(body)
1760  	if err != nil {
1761  		return nil, err
1762  	}
1763  	bodyReader = bytes.NewReader(buf)
1764  	return NewChmodFilesRequestWithBody(server, "application/json", bodyReader)
1765  }
1766  
1767  // NewChmodFilesRequestWithBody generates requests for ChmodFiles with any type of body
1768  func NewChmodFilesRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1769  	var err error
1770  
1771  	serverURL, err := url.Parse(server)
1772  	if err != nil {
1773  		return nil, err
1774  	}
1775  
1776  	operationPath := fmt.Sprintf("/files/permissions")
1777  	if operationPath[0] == '/' {
1778  		operationPath = "." + operationPath
1779  	}
1780  
1781  	queryURL, err := serverURL.Parse(operationPath)
1782  	if err != nil {
1783  		return nil, err
1784  	}
1785  
1786  	req, err := http.NewRequest("POST", queryURL.String(), body)
1787  	if err != nil {
1788  		return nil, err
1789  	}
1790  
1791  	req.Header.Add("Content-Type", contentType)
1792  
1793  	return req, nil
1794  }
1795  
1796  // NewReplaceContentRequest calls the generic ReplaceContent builder with application/json body
1797  func NewReplaceContentRequest(server string, body ReplaceContentJSONRequestBody) (*http.Request, error) {
1798  	var bodyReader io.Reader
1799  	buf, err := json.Marshal(body)
1800  	if err != nil {
1801  		return nil, err
1802  	}
1803  	bodyReader = bytes.NewReader(buf)
1804  	return NewReplaceContentRequestWithBody(server, "application/json", bodyReader)
1805  }
1806  
1807  // NewReplaceContentRequestWithBody generates requests for ReplaceContent with any type of body
1808  func NewReplaceContentRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1809  	var err error
1810  
1811  	serverURL, err := url.Parse(server)
1812  	if err != nil {
1813  		return nil, err
1814  	}
1815  
1816  	operationPath := fmt.Sprintf("/files/replace")
1817  	if operationPath[0] == '/' {
1818  		operationPath = "." + operationPath
1819  	}
1820  
1821  	queryURL, err := serverURL.Parse(operationPath)
1822  	if err != nil {
1823  		return nil, err
1824  	}
1825  
1826  	req, err := http.NewRequest("POST", queryURL.String(), body)
1827  	if err != nil {
1828  		return nil, err
1829  	}
1830  
1831  	req.Header.Add("Content-Type", contentType)
1832  
1833  	return req, nil
1834  }
1835  
1836  // NewSearchFilesRequest generates requests for SearchFiles
1837  func NewSearchFilesRequest(server string, params *SearchFilesParams) (*http.Request, error) {
1838  	var err error
1839  
1840  	serverURL, err := url.Parse(server)
1841  	if err != nil {
1842  		return nil, err
1843  	}
1844  
1845  	operationPath := fmt.Sprintf("/files/search")
1846  	if operationPath[0] == '/' {
1847  		operationPath = "." + operationPath
1848  	}
1849  
1850  	queryURL, err := serverURL.Parse(operationPath)
1851  	if err != nil {
1852  		return nil, err
1853  	}
1854  
1855  	if params != nil {
1856  		queryValues := queryURL.Query()
1857  
1858  		if queryFrag, err := runtime.StyleParamWithOptions("form", true, "path", params.Path, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1859  			return nil, err
1860  		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1861  			return nil, err
1862  		} else {
1863  			for k, v := range parsed {
1864  				for _, v2 := range v {
1865  					queryValues.Add(k, v2)
1866  				}
1867  			}
1868  		}
1869  
1870  		if params.Pattern != nil {
1871  
1872  			if queryFrag, err := runtime.StyleParamWithOptions("form", true, "pattern", *params.Pattern, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationQuery, Type: "string", Format: ""}); err != nil {
1873  				return nil, err
1874  			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
1875  				return nil, err
1876  			} else {
1877  				for k, v := range parsed {
1878  					for _, v2 := range v {
1879  						queryValues.Add(k, v2)
1880  					}
1881  				}
1882  			}
1883  
1884  		}
1885  
1886  		queryURL.RawQuery = queryValues.Encode()
1887  	}
1888  
1889  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1890  	if err != nil {
1891  		return nil, err
1892  	}
1893  
1894  	return req, nil
1895  }
1896  
1897  // NewUploadFileRequestWithBody generates requests for UploadFile with any type of body
1898  func NewUploadFileRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
1899  	var err error
1900  
1901  	serverURL, err := url.Parse(server)
1902  	if err != nil {
1903  		return nil, err
1904  	}
1905  
1906  	operationPath := fmt.Sprintf("/files/upload")
1907  	if operationPath[0] == '/' {
1908  		operationPath = "." + operationPath
1909  	}
1910  
1911  	queryURL, err := serverURL.Parse(operationPath)
1912  	if err != nil {
1913  		return nil, err
1914  	}
1915  
1916  	req, err := http.NewRequest("POST", queryURL.String(), body)
1917  	if err != nil {
1918  		return nil, err
1919  	}
1920  
1921  	req.Header.Add("Content-Type", contentType)
1922  
1923  	return req, nil
1924  }
1925  
1926  // NewGetMetricsRequest generates requests for GetMetrics
1927  func NewGetMetricsRequest(server string) (*http.Request, error) {
1928  	var err error
1929  
1930  	serverURL, err := url.Parse(server)
1931  	if err != nil {
1932  		return nil, err
1933  	}
1934  
1935  	operationPath := fmt.Sprintf("/metrics")
1936  	if operationPath[0] == '/' {
1937  		operationPath = "." + operationPath
1938  	}
1939  
1940  	queryURL, err := serverURL.Parse(operationPath)
1941  	if err != nil {
1942  		return nil, err
1943  	}
1944  
1945  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1946  	if err != nil {
1947  		return nil, err
1948  	}
1949  
1950  	return req, nil
1951  }
1952  
1953  // NewWatchMetricsRequest generates requests for WatchMetrics
1954  func NewWatchMetricsRequest(server string) (*http.Request, error) {
1955  	var err error
1956  
1957  	serverURL, err := url.Parse(server)
1958  	if err != nil {
1959  		return nil, err
1960  	}
1961  
1962  	operationPath := fmt.Sprintf("/metrics/watch")
1963  	if operationPath[0] == '/' {
1964  		operationPath = "." + operationPath
1965  	}
1966  
1967  	queryURL, err := serverURL.Parse(operationPath)
1968  	if err != nil {
1969  		return nil, err
1970  	}
1971  
1972  	req, err := http.NewRequest("GET", queryURL.String(), nil)
1973  	if err != nil {
1974  		return nil, err
1975  	}
1976  
1977  	return req, nil
1978  }
1979  
1980  // NewPingRequest generates requests for Ping
1981  func NewPingRequest(server string) (*http.Request, error) {
1982  	var err error
1983  
1984  	serverURL, err := url.Parse(server)
1985  	if err != nil {
1986  		return nil, err
1987  	}
1988  
1989  	operationPath := fmt.Sprintf("/ping")
1990  	if operationPath[0] == '/' {
1991  		operationPath = "." + operationPath
1992  	}
1993  
1994  	queryURL, err := serverURL.Parse(operationPath)
1995  	if err != nil {
1996  		return nil, err
1997  	}
1998  
1999  	req, err := http.NewRequest("GET", queryURL.String(), nil)
2000  	if err != nil {
2001  		return nil, err
2002  	}
2003  
2004  	return req, nil
2005  }
2006  
2007  // NewCreateSessionRequest calls the generic CreateSession builder with application/json body
2008  func NewCreateSessionRequest(server string, body CreateSessionJSONRequestBody) (*http.Request, error) {
2009  	var bodyReader io.Reader
2010  	buf, err := json.Marshal(body)
2011  	if err != nil {
2012  		return nil, err
2013  	}
2014  	bodyReader = bytes.NewReader(buf)
2015  	return NewCreateSessionRequestWithBody(server, "application/json", bodyReader)
2016  }
2017  
2018  // NewCreateSessionRequestWithBody generates requests for CreateSession with any type of body
2019  func NewCreateSessionRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
2020  	var err error
2021  
2022  	serverURL, err := url.Parse(server)
2023  	if err != nil {
2024  		return nil, err
2025  	}
2026  
2027  	operationPath := fmt.Sprintf("/session")
2028  	if operationPath[0] == '/' {
2029  		operationPath = "." + operationPath
2030  	}
2031  
2032  	queryURL, err := serverURL.Parse(operationPath)
2033  	if err != nil {
2034  		return nil, err
2035  	}
2036  
2037  	req, err := http.NewRequest("POST", queryURL.String(), body)
2038  	if err != nil {
2039  		return nil, err
2040  	}
2041  
2042  	req.Header.Add("Content-Type", contentType)
2043  
2044  	return req, nil
2045  }
2046  
2047  // NewDeleteSessionRequest generates requests for DeleteSession
2048  func NewDeleteSessionRequest(server string, sessionID string) (*http.Request, error) {
2049  	var err error
2050  
2051  	var pathParam0 string
2052  
2053  	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "sessionId", sessionID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
2054  	if err != nil {
2055  		return nil, err
2056  	}
2057  
2058  	serverURL, err := url.Parse(server)
2059  	if err != nil {
2060  		return nil, err
2061  	}
2062  
2063  	operationPath := fmt.Sprintf("/session/%s", pathParam0)
2064  	if operationPath[0] == '/' {
2065  		operationPath = "." + operationPath
2066  	}
2067  
2068  	queryURL, err := serverURL.Parse(operationPath)
2069  	if err != nil {
2070  		return nil, err
2071  	}
2072  
2073  	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
2074  	if err != nil {
2075  		return nil, err
2076  	}
2077  
2078  	return req, nil
2079  }
2080  
2081  // NewRunInSessionRequest calls the generic RunInSession builder with application/json body
2082  func NewRunInSessionRequest(server string, sessionID string, body RunInSessionJSONRequestBody) (*http.Request, error) {
2083  	var bodyReader io.Reader
2084  	buf, err := json.Marshal(body)
2085  	if err != nil {
2086  		return nil, err
2087  	}
2088  	bodyReader = bytes.NewReader(buf)
2089  	return NewRunInSessionRequestWithBody(server, sessionID, "application/json", bodyReader)
2090  }
2091  
2092  // NewRunInSessionRequestWithBody generates requests for RunInSession with any type of body
2093  func NewRunInSessionRequestWithBody(server string, sessionID string, contentType string, body io.Reader) (*http.Request, error) {
2094  	var err error
2095  
2096  	var pathParam0 string
2097  
2098  	pathParam0, err = runtime.StyleParamWithOptions("simple", false, "sessionId", sessionID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""})
2099  	if err != nil {
2100  		return nil, err
2101  	}
2102  
2103  	serverURL, err := url.Parse(server)
2104  	if err != nil {
2105  		return nil, err
2106  	}
2107  
2108  	operationPath := fmt.Sprintf("/session/%s/run", pathParam0)
2109  	if operationPath[0] == '/' {
2110  		operationPath = "." + operationPath
2111  	}
2112  
2113  	queryURL, err := serverURL.Parse(operationPath)
2114  	if err != nil {
2115  		return nil, err
2116  	}
2117  
2118  	req, err := http.NewRequest("POST", queryURL.String(), body)
2119  	if err != nil {
2120  		return nil, err
2121  	}
2122  
2123  	req.Header.Add("Content-Type", contentType)
2124  
2125  	return req, nil
2126  }
2127  
2128  func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
2129  	for _, r := range c.RequestEditors {
2130  		if err := r(ctx, req); err != nil {
2131  			return err
2132  		}
2133  	}
2134  	for _, r := range additionalEditors {
2135  		if err := r(ctx, req); err != nil {
2136  			return err
2137  		}
2138  	}
2139  	return nil
2140  }
2141  
2142  // ClientWithResponses builds on ClientInterface to offer response payloads
2143  type ClientWithResponses struct {
2144  	ClientInterface
2145  }
2146  
2147  // NewClientWithResponses creates a new ClientWithResponses, which wraps
2148  // Client with return type handling
2149  func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
2150  	client, err := NewClient(server, opts...)
2151  	if err != nil {
2152  		return nil, err
2153  	}
2154  	return &ClientWithResponses{client}, nil
2155  }
2156  
2157  // WithBaseURL overrides the baseURL.
2158  func WithBaseURL(baseURL string) ClientOption {
2159  	return func(c *Client) error {
2160  		newBaseURL, err := url.Parse(baseURL)
2161  		if err != nil {
2162  			return err
2163  		}
2164  		c.Server = newBaseURL.String()
2165  		return nil
2166  	}
2167  }
2168  
2169  // ClientWithResponsesInterface is the interface specification for the client with responses above.
2170  type ClientWithResponsesInterface interface {
2171  	// InterruptCodeWithResponse request
2172  	InterruptCodeWithResponse(ctx context.Context, params *InterruptCodeParams, reqEditors ...RequestEditorFn) (*InterruptCodeResponse, error)
2173  
2174  	// RunCodeWithBodyWithResponse request with any body
2175  	RunCodeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RunCodeResponse, error)
2176  
2177  	RunCodeWithResponse(ctx context.Context, body RunCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*RunCodeResponse, error)
2178  
2179  	// CreateCodeContextWithBodyWithResponse request with any body
2180  	CreateCodeContextWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateCodeContextResponse, error)
2181  
2182  	CreateCodeContextWithResponse(ctx context.Context, body CreateCodeContextJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateCodeContextResponse, error)
2183  
2184  	// DeleteContextsByLanguageWithResponse request
2185  	DeleteContextsByLanguageWithResponse(ctx context.Context, params *DeleteContextsByLanguageParams, reqEditors ...RequestEditorFn) (*DeleteContextsByLanguageResponse, error)
2186  
2187  	// ListContextsWithResponse request
2188  	ListContextsWithResponse(ctx context.Context, params *ListContextsParams, reqEditors ...RequestEditorFn) (*ListContextsResponse, error)
2189  
2190  	// DeleteContextWithResponse request
2191  	DeleteContextWithResponse(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*DeleteContextResponse, error)
2192  
2193  	// GetContextWithResponse request
2194  	GetContextWithResponse(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*GetContextResponse, error)
2195  
2196  	// InterruptCommandWithResponse request
2197  	InterruptCommandWithResponse(ctx context.Context, params *InterruptCommandParams, reqEditors ...RequestEditorFn) (*InterruptCommandResponse, error)
2198  
2199  	// RunCommandWithBodyWithResponse request with any body
2200  	RunCommandWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RunCommandResponse, error)
2201  
2202  	RunCommandWithResponse(ctx context.Context, body RunCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*RunCommandResponse, error)
2203  
2204  	// GetCommandStatusWithResponse request
2205  	GetCommandStatusWithResponse(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*GetCommandStatusResponse, error)
2206  
2207  	// GetBackgroundCommandLogsWithResponse request
2208  	GetBackgroundCommandLogsWithResponse(ctx context.Context, id string, params *GetBackgroundCommandLogsParams, reqEditors ...RequestEditorFn) (*GetBackgroundCommandLogsResponse, error)
2209  
2210  	// RemoveDirsWithResponse request
2211  	RemoveDirsWithResponse(ctx context.Context, params *RemoveDirsParams, reqEditors ...RequestEditorFn) (*RemoveDirsResponse, error)
2212  
2213  	// MakeDirsWithBodyWithResponse request with any body
2214  	MakeDirsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MakeDirsResponse, error)
2215  
2216  	MakeDirsWithResponse(ctx context.Context, body MakeDirsJSONRequestBody, reqEditors ...RequestEditorFn) (*MakeDirsResponse, error)
2217  
2218  	// RemoveFilesWithResponse request
2219  	RemoveFilesWithResponse(ctx context.Context, params *RemoveFilesParams, reqEditors ...RequestEditorFn) (*RemoveFilesResponse, error)
2220  
2221  	// DownloadFileWithResponse request
2222  	DownloadFileWithResponse(ctx context.Context, params *DownloadFileParams, reqEditors ...RequestEditorFn) (*DownloadFileResponse, error)
2223  
2224  	// GetFilesInfoWithResponse request
2225  	GetFilesInfoWithResponse(ctx context.Context, params *GetFilesInfoParams, reqEditors ...RequestEditorFn) (*GetFilesInfoResponse, error)
2226  
2227  	// RenameFilesWithBodyWithResponse request with any body
2228  	RenameFilesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RenameFilesResponse, error)
2229  
2230  	RenameFilesWithResponse(ctx context.Context, body RenameFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*RenameFilesResponse, error)
2231  
2232  	// ChmodFilesWithBodyWithResponse request with any body
2233  	ChmodFilesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ChmodFilesResponse, error)
2234  
2235  	ChmodFilesWithResponse(ctx context.Context, body ChmodFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*ChmodFilesResponse, error)
2236  
2237  	// ReplaceContentWithBodyWithResponse request with any body
2238  	ReplaceContentWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ReplaceContentResponse, error)
2239  
2240  	ReplaceContentWithResponse(ctx context.Context, body ReplaceContentJSONRequestBody, reqEditors ...RequestEditorFn) (*ReplaceContentResponse, error)
2241  
2242  	// SearchFilesWithResponse request
2243  	SearchFilesWithResponse(ctx context.Context, params *SearchFilesParams, reqEditors ...RequestEditorFn) (*SearchFilesResponse, error)
2244  
2245  	// UploadFileWithBodyWithResponse request with any body
2246  	UploadFileWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UploadFileResponse, error)
2247  
2248  	// GetMetricsWithResponse request
2249  	GetMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMetricsResponse, error)
2250  
2251  	// WatchMetricsWithResponse request
2252  	WatchMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*WatchMetricsResponse, error)
2253  
2254  	// PingWithResponse request
2255  	PingWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PingResponse, error)
2256  
2257  	// CreateSessionWithBodyWithResponse request with any body
2258  	CreateSessionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateSessionResponse, error)
2259  
2260  	CreateSessionWithResponse(ctx context.Context, body CreateSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateSessionResponse, error)
2261  
2262  	// DeleteSessionWithResponse request
2263  	DeleteSessionWithResponse(ctx context.Context, sessionID string, reqEditors ...RequestEditorFn) (*DeleteSessionResponse, error)
2264  
2265  	// RunInSessionWithBodyWithResponse request with any body
2266  	RunInSessionWithBodyWithResponse(ctx context.Context, sessionID string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RunInSessionResponse, error)
2267  
2268  	RunInSessionWithResponse(ctx context.Context, sessionID string, body RunInSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*RunInSessionResponse, error)
2269  }
2270  
2271  type InterruptCodeResponse struct {
2272  	Body         []byte
2273  	HTTPResponse *http.Response
2274  	JSON400      *BadRequest
2275  	JSON500      *InternalServerError
2276  }
2277  
2278  // Status returns HTTPResponse.Status
2279  func (r InterruptCodeResponse) Status() string {
2280  	if r.HTTPResponse != nil {
2281  		return r.HTTPResponse.Status
2282  	}
2283  	return http.StatusText(0)
2284  }
2285  
2286  // StatusCode returns HTTPResponse.StatusCode
2287  func (r InterruptCodeResponse) StatusCode() int {
2288  	if r.HTTPResponse != nil {
2289  		return r.HTTPResponse.StatusCode
2290  	}
2291  	return 0
2292  }
2293  
2294  type RunCodeResponse struct {
2295  	Body         []byte
2296  	HTTPResponse *http.Response
2297  	JSON400      *BadRequest
2298  	JSON500      *InternalServerError
2299  }
2300  
2301  // Status returns HTTPResponse.Status
2302  func (r RunCodeResponse) Status() string {
2303  	if r.HTTPResponse != nil {
2304  		return r.HTTPResponse.Status
2305  	}
2306  	return http.StatusText(0)
2307  }
2308  
2309  // StatusCode returns HTTPResponse.StatusCode
2310  func (r RunCodeResponse) StatusCode() int {
2311  	if r.HTTPResponse != nil {
2312  		return r.HTTPResponse.StatusCode
2313  	}
2314  	return 0
2315  }
2316  
2317  type CreateCodeContextResponse struct {
2318  	Body         []byte
2319  	HTTPResponse *http.Response
2320  	JSON200      *CodeContext
2321  	JSON400      *BadRequest
2322  	JSON500      *InternalServerError
2323  }
2324  
2325  // Status returns HTTPResponse.Status
2326  func (r CreateCodeContextResponse) Status() string {
2327  	if r.HTTPResponse != nil {
2328  		return r.HTTPResponse.Status
2329  	}
2330  	return http.StatusText(0)
2331  }
2332  
2333  // StatusCode returns HTTPResponse.StatusCode
2334  func (r CreateCodeContextResponse) StatusCode() int {
2335  	if r.HTTPResponse != nil {
2336  		return r.HTTPResponse.StatusCode
2337  	}
2338  	return 0
2339  }
2340  
2341  type DeleteContextsByLanguageResponse struct {
2342  	Body         []byte
2343  	HTTPResponse *http.Response
2344  	JSON400      *BadRequest
2345  	JSON500      *InternalServerError
2346  }
2347  
2348  // Status returns HTTPResponse.Status
2349  func (r DeleteContextsByLanguageResponse) Status() string {
2350  	if r.HTTPResponse != nil {
2351  		return r.HTTPResponse.Status
2352  	}
2353  	return http.StatusText(0)
2354  }
2355  
2356  // StatusCode returns HTTPResponse.StatusCode
2357  func (r DeleteContextsByLanguageResponse) StatusCode() int {
2358  	if r.HTTPResponse != nil {
2359  		return r.HTTPResponse.StatusCode
2360  	}
2361  	return 0
2362  }
2363  
2364  type ListContextsResponse struct {
2365  	Body         []byte
2366  	HTTPResponse *http.Response
2367  	JSON200      *[]CodeContext
2368  	JSON400      *BadRequest
2369  	JSON500      *InternalServerError
2370  }
2371  
2372  // Status returns HTTPResponse.Status
2373  func (r ListContextsResponse) Status() string {
2374  	if r.HTTPResponse != nil {
2375  		return r.HTTPResponse.Status
2376  	}
2377  	return http.StatusText(0)
2378  }
2379  
2380  // StatusCode returns HTTPResponse.StatusCode
2381  func (r ListContextsResponse) StatusCode() int {
2382  	if r.HTTPResponse != nil {
2383  		return r.HTTPResponse.StatusCode
2384  	}
2385  	return 0
2386  }
2387  
2388  type DeleteContextResponse struct {
2389  	Body         []byte
2390  	HTTPResponse *http.Response
2391  	JSON400      *BadRequest
2392  	JSON404      *NotFound
2393  	JSON500      *InternalServerError
2394  }
2395  
2396  // Status returns HTTPResponse.Status
2397  func (r DeleteContextResponse) Status() string {
2398  	if r.HTTPResponse != nil {
2399  		return r.HTTPResponse.Status
2400  	}
2401  	return http.StatusText(0)
2402  }
2403  
2404  // StatusCode returns HTTPResponse.StatusCode
2405  func (r DeleteContextResponse) StatusCode() int {
2406  	if r.HTTPResponse != nil {
2407  		return r.HTTPResponse.StatusCode
2408  	}
2409  	return 0
2410  }
2411  
2412  type GetContextResponse struct {
2413  	Body         []byte
2414  	HTTPResponse *http.Response
2415  	JSON200      *CodeContext
2416  	JSON404      *NotFound
2417  	JSON500      *InternalServerError
2418  }
2419  
2420  // Status returns HTTPResponse.Status
2421  func (r GetContextResponse) Status() string {
2422  	if r.HTTPResponse != nil {
2423  		return r.HTTPResponse.Status
2424  	}
2425  	return http.StatusText(0)
2426  }
2427  
2428  // StatusCode returns HTTPResponse.StatusCode
2429  func (r GetContextResponse) StatusCode() int {
2430  	if r.HTTPResponse != nil {
2431  		return r.HTTPResponse.StatusCode
2432  	}
2433  	return 0
2434  }
2435  
2436  type InterruptCommandResponse struct {
2437  	Body         []byte
2438  	HTTPResponse *http.Response
2439  	JSON400      *BadRequest
2440  	JSON500      *InternalServerError
2441  }
2442  
2443  // Status returns HTTPResponse.Status
2444  func (r InterruptCommandResponse) Status() string {
2445  	if r.HTTPResponse != nil {
2446  		return r.HTTPResponse.Status
2447  	}
2448  	return http.StatusText(0)
2449  }
2450  
2451  // StatusCode returns HTTPResponse.StatusCode
2452  func (r InterruptCommandResponse) StatusCode() int {
2453  	if r.HTTPResponse != nil {
2454  		return r.HTTPResponse.StatusCode
2455  	}
2456  	return 0
2457  }
2458  
2459  type RunCommandResponse struct {
2460  	Body         []byte
2461  	HTTPResponse *http.Response
2462  	JSON400      *BadRequest
2463  	JSON500      *InternalServerError
2464  }
2465  
2466  // Status returns HTTPResponse.Status
2467  func (r RunCommandResponse) Status() string {
2468  	if r.HTTPResponse != nil {
2469  		return r.HTTPResponse.Status
2470  	}
2471  	return http.StatusText(0)
2472  }
2473  
2474  // StatusCode returns HTTPResponse.StatusCode
2475  func (r RunCommandResponse) StatusCode() int {
2476  	if r.HTTPResponse != nil {
2477  		return r.HTTPResponse.StatusCode
2478  	}
2479  	return 0
2480  }
2481  
2482  type GetCommandStatusResponse struct {
2483  	Body         []byte
2484  	HTTPResponse *http.Response
2485  	JSON200      *CommandStatusResponse
2486  	JSON400      *BadRequest
2487  	JSON404      *NotFound
2488  	JSON500      *InternalServerError
2489  }
2490  
2491  // Status returns HTTPResponse.Status
2492  func (r GetCommandStatusResponse) Status() string {
2493  	if r.HTTPResponse != nil {
2494  		return r.HTTPResponse.Status
2495  	}
2496  	return http.StatusText(0)
2497  }
2498  
2499  // StatusCode returns HTTPResponse.StatusCode
2500  func (r GetCommandStatusResponse) StatusCode() int {
2501  	if r.HTTPResponse != nil {
2502  		return r.HTTPResponse.StatusCode
2503  	}
2504  	return 0
2505  }
2506  
2507  type GetBackgroundCommandLogsResponse struct {
2508  	Body         []byte
2509  	HTTPResponse *http.Response
2510  	JSON400      *BadRequest
2511  	JSON404      *NotFound
2512  	JSON500      *InternalServerError
2513  }
2514  
2515  // Status returns HTTPResponse.Status
2516  func (r GetBackgroundCommandLogsResponse) Status() string {
2517  	if r.HTTPResponse != nil {
2518  		return r.HTTPResponse.Status
2519  	}
2520  	return http.StatusText(0)
2521  }
2522  
2523  // StatusCode returns HTTPResponse.StatusCode
2524  func (r GetBackgroundCommandLogsResponse) StatusCode() int {
2525  	if r.HTTPResponse != nil {
2526  		return r.HTTPResponse.StatusCode
2527  	}
2528  	return 0
2529  }
2530  
2531  type RemoveDirsResponse struct {
2532  	Body         []byte
2533  	HTTPResponse *http.Response
2534  	JSON500      *InternalServerError
2535  }
2536  
2537  // Status returns HTTPResponse.Status
2538  func (r RemoveDirsResponse) Status() string {
2539  	if r.HTTPResponse != nil {
2540  		return r.HTTPResponse.Status
2541  	}
2542  	return http.StatusText(0)
2543  }
2544  
2545  // StatusCode returns HTTPResponse.StatusCode
2546  func (r RemoveDirsResponse) StatusCode() int {
2547  	if r.HTTPResponse != nil {
2548  		return r.HTTPResponse.StatusCode
2549  	}
2550  	return 0
2551  }
2552  
2553  type MakeDirsResponse struct {
2554  	Body         []byte
2555  	HTTPResponse *http.Response
2556  	JSON400      *BadRequest
2557  	JSON500      *InternalServerError
2558  }
2559  
2560  // Status returns HTTPResponse.Status
2561  func (r MakeDirsResponse) Status() string {
2562  	if r.HTTPResponse != nil {
2563  		return r.HTTPResponse.Status
2564  	}
2565  	return http.StatusText(0)
2566  }
2567  
2568  // StatusCode returns HTTPResponse.StatusCode
2569  func (r MakeDirsResponse) StatusCode() int {
2570  	if r.HTTPResponse != nil {
2571  		return r.HTTPResponse.StatusCode
2572  	}
2573  	return 0
2574  }
2575  
2576  type RemoveFilesResponse struct {
2577  	Body         []byte
2578  	HTTPResponse *http.Response
2579  	JSON500      *InternalServerError
2580  }
2581  
2582  // Status returns HTTPResponse.Status
2583  func (r RemoveFilesResponse) Status() string {
2584  	if r.HTTPResponse != nil {
2585  		return r.HTTPResponse.Status
2586  	}
2587  	return http.StatusText(0)
2588  }
2589  
2590  // StatusCode returns HTTPResponse.StatusCode
2591  func (r RemoveFilesResponse) StatusCode() int {
2592  	if r.HTTPResponse != nil {
2593  		return r.HTTPResponse.StatusCode
2594  	}
2595  	return 0
2596  }
2597  
2598  type DownloadFileResponse struct {
2599  	Body         []byte
2600  	HTTPResponse *http.Response
2601  	JSON400      *BadRequest
2602  	JSON404      *NotFound
2603  	JSON416      *ErrorResponse
2604  	JSON500      *InternalServerError
2605  }
2606  
2607  // Status returns HTTPResponse.Status
2608  func (r DownloadFileResponse) Status() string {
2609  	if r.HTTPResponse != nil {
2610  		return r.HTTPResponse.Status
2611  	}
2612  	return http.StatusText(0)
2613  }
2614  
2615  // StatusCode returns HTTPResponse.StatusCode
2616  func (r DownloadFileResponse) StatusCode() int {
2617  	if r.HTTPResponse != nil {
2618  		return r.HTTPResponse.StatusCode
2619  	}
2620  	return 0
2621  }
2622  
2623  type GetFilesInfoResponse struct {
2624  	Body         []byte
2625  	HTTPResponse *http.Response
2626  	JSON200      *map[string]FileInfo
2627  	JSON404      *NotFound
2628  	JSON500      *InternalServerError
2629  }
2630  
2631  // Status returns HTTPResponse.Status
2632  func (r GetFilesInfoResponse) Status() string {
2633  	if r.HTTPResponse != nil {
2634  		return r.HTTPResponse.Status
2635  	}
2636  	return http.StatusText(0)
2637  }
2638  
2639  // StatusCode returns HTTPResponse.StatusCode
2640  func (r GetFilesInfoResponse) StatusCode() int {
2641  	if r.HTTPResponse != nil {
2642  		return r.HTTPResponse.StatusCode
2643  	}
2644  	return 0
2645  }
2646  
2647  type RenameFilesResponse struct {
2648  	Body         []byte
2649  	HTTPResponse *http.Response
2650  	JSON400      *BadRequest
2651  	JSON404      *NotFound
2652  	JSON500      *InternalServerError
2653  }
2654  
2655  // Status returns HTTPResponse.Status
2656  func (r RenameFilesResponse) Status() string {
2657  	if r.HTTPResponse != nil {
2658  		return r.HTTPResponse.Status
2659  	}
2660  	return http.StatusText(0)
2661  }
2662  
2663  // StatusCode returns HTTPResponse.StatusCode
2664  func (r RenameFilesResponse) StatusCode() int {
2665  	if r.HTTPResponse != nil {
2666  		return r.HTTPResponse.StatusCode
2667  	}
2668  	return 0
2669  }
2670  
2671  type ChmodFilesResponse struct {
2672  	Body         []byte
2673  	HTTPResponse *http.Response
2674  	JSON400      *BadRequest
2675  	JSON500      *InternalServerError
2676  }
2677  
2678  // Status returns HTTPResponse.Status
2679  func (r ChmodFilesResponse) Status() string {
2680  	if r.HTTPResponse != nil {
2681  		return r.HTTPResponse.Status
2682  	}
2683  	return http.StatusText(0)
2684  }
2685  
2686  // StatusCode returns HTTPResponse.StatusCode
2687  func (r ChmodFilesResponse) StatusCode() int {
2688  	if r.HTTPResponse != nil {
2689  		return r.HTTPResponse.StatusCode
2690  	}
2691  	return 0
2692  }
2693  
2694  type ReplaceContentResponse struct {
2695  	Body         []byte
2696  	HTTPResponse *http.Response
2697  	JSON400      *BadRequest
2698  	JSON500      *InternalServerError
2699  }
2700  
2701  // Status returns HTTPResponse.Status
2702  func (r ReplaceContentResponse) Status() string {
2703  	if r.HTTPResponse != nil {
2704  		return r.HTTPResponse.Status
2705  	}
2706  	return http.StatusText(0)
2707  }
2708  
2709  // StatusCode returns HTTPResponse.StatusCode
2710  func (r ReplaceContentResponse) StatusCode() int {
2711  	if r.HTTPResponse != nil {
2712  		return r.HTTPResponse.StatusCode
2713  	}
2714  	return 0
2715  }
2716  
2717  type SearchFilesResponse struct {
2718  	Body         []byte
2719  	HTTPResponse *http.Response
2720  	JSON200      *[]FileInfo
2721  	JSON400      *BadRequest
2722  	JSON404      *NotFound
2723  	JSON500      *InternalServerError
2724  }
2725  
2726  // Status returns HTTPResponse.Status
2727  func (r SearchFilesResponse) Status() string {
2728  	if r.HTTPResponse != nil {
2729  		return r.HTTPResponse.Status
2730  	}
2731  	return http.StatusText(0)
2732  }
2733  
2734  // StatusCode returns HTTPResponse.StatusCode
2735  func (r SearchFilesResponse) StatusCode() int {
2736  	if r.HTTPResponse != nil {
2737  		return r.HTTPResponse.StatusCode
2738  	}
2739  	return 0
2740  }
2741  
2742  type UploadFileResponse struct {
2743  	Body         []byte
2744  	HTTPResponse *http.Response
2745  	JSON400      *BadRequest
2746  	JSON500      *InternalServerError
2747  }
2748  
2749  // Status returns HTTPResponse.Status
2750  func (r UploadFileResponse) Status() string {
2751  	if r.HTTPResponse != nil {
2752  		return r.HTTPResponse.Status
2753  	}
2754  	return http.StatusText(0)
2755  }
2756  
2757  // StatusCode returns HTTPResponse.StatusCode
2758  func (r UploadFileResponse) StatusCode() int {
2759  	if r.HTTPResponse != nil {
2760  		return r.HTTPResponse.StatusCode
2761  	}
2762  	return 0
2763  }
2764  
2765  type GetMetricsResponse struct {
2766  	Body         []byte
2767  	HTTPResponse *http.Response
2768  	JSON200      *Metrics
2769  	JSON500      *InternalServerError
2770  }
2771  
2772  // Status returns HTTPResponse.Status
2773  func (r GetMetricsResponse) Status() string {
2774  	if r.HTTPResponse != nil {
2775  		return r.HTTPResponse.Status
2776  	}
2777  	return http.StatusText(0)
2778  }
2779  
2780  // StatusCode returns HTTPResponse.StatusCode
2781  func (r GetMetricsResponse) StatusCode() int {
2782  	if r.HTTPResponse != nil {
2783  		return r.HTTPResponse.StatusCode
2784  	}
2785  	return 0
2786  }
2787  
2788  type WatchMetricsResponse struct {
2789  	Body         []byte
2790  	HTTPResponse *http.Response
2791  	JSON500      *InternalServerError
2792  }
2793  
2794  // Status returns HTTPResponse.Status
2795  func (r WatchMetricsResponse) Status() string {
2796  	if r.HTTPResponse != nil {
2797  		return r.HTTPResponse.Status
2798  	}
2799  	return http.StatusText(0)
2800  }
2801  
2802  // StatusCode returns HTTPResponse.StatusCode
2803  func (r WatchMetricsResponse) StatusCode() int {
2804  	if r.HTTPResponse != nil {
2805  		return r.HTTPResponse.StatusCode
2806  	}
2807  	return 0
2808  }
2809  
2810  type PingResponse struct {
2811  	Body         []byte
2812  	HTTPResponse *http.Response
2813  }
2814  
2815  // Status returns HTTPResponse.Status
2816  func (r PingResponse) Status() string {
2817  	if r.HTTPResponse != nil {
2818  		return r.HTTPResponse.Status
2819  	}
2820  	return http.StatusText(0)
2821  }
2822  
2823  // StatusCode returns HTTPResponse.StatusCode
2824  func (r PingResponse) StatusCode() int {
2825  	if r.HTTPResponse != nil {
2826  		return r.HTTPResponse.StatusCode
2827  	}
2828  	return 0
2829  }
2830  
2831  type CreateSessionResponse struct {
2832  	Body         []byte
2833  	HTTPResponse *http.Response
2834  	JSON200      *SessionCreated
2835  	JSON400      *BadRequest
2836  	JSON500      *InternalServerError
2837  }
2838  
2839  // Status returns HTTPResponse.Status
2840  func (r CreateSessionResponse) Status() string {
2841  	if r.HTTPResponse != nil {
2842  		return r.HTTPResponse.Status
2843  	}
2844  	return http.StatusText(0)
2845  }
2846  
2847  // StatusCode returns HTTPResponse.StatusCode
2848  func (r CreateSessionResponse) StatusCode() int {
2849  	if r.HTTPResponse != nil {
2850  		return r.HTTPResponse.StatusCode
2851  	}
2852  	return 0
2853  }
2854  
2855  type DeleteSessionResponse struct {
2856  	Body         []byte
2857  	HTTPResponse *http.Response
2858  	JSON400      *BadRequest
2859  	JSON404      *NotFound
2860  	JSON500      *InternalServerError
2861  }
2862  
2863  // Status returns HTTPResponse.Status
2864  func (r DeleteSessionResponse) Status() string {
2865  	if r.HTTPResponse != nil {
2866  		return r.HTTPResponse.Status
2867  	}
2868  	return http.StatusText(0)
2869  }
2870  
2871  // StatusCode returns HTTPResponse.StatusCode
2872  func (r DeleteSessionResponse) StatusCode() int {
2873  	if r.HTTPResponse != nil {
2874  		return r.HTTPResponse.StatusCode
2875  	}
2876  	return 0
2877  }
2878  
2879  type RunInSessionResponse struct {
2880  	Body         []byte
2881  	HTTPResponse *http.Response
2882  	JSON400      *BadRequest
2883  	JSON500      *InternalServerError
2884  }
2885  
2886  // Status returns HTTPResponse.Status
2887  func (r RunInSessionResponse) Status() string {
2888  	if r.HTTPResponse != nil {
2889  		return r.HTTPResponse.Status
2890  	}
2891  	return http.StatusText(0)
2892  }
2893  
2894  // StatusCode returns HTTPResponse.StatusCode
2895  func (r RunInSessionResponse) StatusCode() int {
2896  	if r.HTTPResponse != nil {
2897  		return r.HTTPResponse.StatusCode
2898  	}
2899  	return 0
2900  }
2901  
2902  // InterruptCodeWithResponse request returning *InterruptCodeResponse
2903  func (c *ClientWithResponses) InterruptCodeWithResponse(ctx context.Context, params *InterruptCodeParams, reqEditors ...RequestEditorFn) (*InterruptCodeResponse, error) {
2904  	rsp, err := c.InterruptCode(ctx, params, reqEditors...)
2905  	if err != nil {
2906  		return nil, err
2907  	}
2908  	return ParseInterruptCodeResponse(rsp)
2909  }
2910  
2911  // RunCodeWithBodyWithResponse request with arbitrary body returning *RunCodeResponse
2912  func (c *ClientWithResponses) RunCodeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RunCodeResponse, error) {
2913  	rsp, err := c.RunCodeWithBody(ctx, contentType, body, reqEditors...)
2914  	if err != nil {
2915  		return nil, err
2916  	}
2917  	return ParseRunCodeResponse(rsp)
2918  }
2919  
2920  func (c *ClientWithResponses) RunCodeWithResponse(ctx context.Context, body RunCodeJSONRequestBody, reqEditors ...RequestEditorFn) (*RunCodeResponse, error) {
2921  	rsp, err := c.RunCode(ctx, body, reqEditors...)
2922  	if err != nil {
2923  		return nil, err
2924  	}
2925  	return ParseRunCodeResponse(rsp)
2926  }
2927  
2928  // CreateCodeContextWithBodyWithResponse request with arbitrary body returning *CreateCodeContextResponse
2929  func (c *ClientWithResponses) CreateCodeContextWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateCodeContextResponse, error) {
2930  	rsp, err := c.CreateCodeContextWithBody(ctx, contentType, body, reqEditors...)
2931  	if err != nil {
2932  		return nil, err
2933  	}
2934  	return ParseCreateCodeContextResponse(rsp)
2935  }
2936  
2937  func (c *ClientWithResponses) CreateCodeContextWithResponse(ctx context.Context, body CreateCodeContextJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateCodeContextResponse, error) {
2938  	rsp, err := c.CreateCodeContext(ctx, body, reqEditors...)
2939  	if err != nil {
2940  		return nil, err
2941  	}
2942  	return ParseCreateCodeContextResponse(rsp)
2943  }
2944  
2945  // DeleteContextsByLanguageWithResponse request returning *DeleteContextsByLanguageResponse
2946  func (c *ClientWithResponses) DeleteContextsByLanguageWithResponse(ctx context.Context, params *DeleteContextsByLanguageParams, reqEditors ...RequestEditorFn) (*DeleteContextsByLanguageResponse, error) {
2947  	rsp, err := c.DeleteContextsByLanguage(ctx, params, reqEditors...)
2948  	if err != nil {
2949  		return nil, err
2950  	}
2951  	return ParseDeleteContextsByLanguageResponse(rsp)
2952  }
2953  
2954  // ListContextsWithResponse request returning *ListContextsResponse
2955  func (c *ClientWithResponses) ListContextsWithResponse(ctx context.Context, params *ListContextsParams, reqEditors ...RequestEditorFn) (*ListContextsResponse, error) {
2956  	rsp, err := c.ListContexts(ctx, params, reqEditors...)
2957  	if err != nil {
2958  		return nil, err
2959  	}
2960  	return ParseListContextsResponse(rsp)
2961  }
2962  
2963  // DeleteContextWithResponse request returning *DeleteContextResponse
2964  func (c *ClientWithResponses) DeleteContextWithResponse(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*DeleteContextResponse, error) {
2965  	rsp, err := c.DeleteContext(ctx, contextID, reqEditors...)
2966  	if err != nil {
2967  		return nil, err
2968  	}
2969  	return ParseDeleteContextResponse(rsp)
2970  }
2971  
2972  // GetContextWithResponse request returning *GetContextResponse
2973  func (c *ClientWithResponses) GetContextWithResponse(ctx context.Context, contextID string, reqEditors ...RequestEditorFn) (*GetContextResponse, error) {
2974  	rsp, err := c.GetContext(ctx, contextID, reqEditors...)
2975  	if err != nil {
2976  		return nil, err
2977  	}
2978  	return ParseGetContextResponse(rsp)
2979  }
2980  
2981  // InterruptCommandWithResponse request returning *InterruptCommandResponse
2982  func (c *ClientWithResponses) InterruptCommandWithResponse(ctx context.Context, params *InterruptCommandParams, reqEditors ...RequestEditorFn) (*InterruptCommandResponse, error) {
2983  	rsp, err := c.InterruptCommand(ctx, params, reqEditors...)
2984  	if err != nil {
2985  		return nil, err
2986  	}
2987  	return ParseInterruptCommandResponse(rsp)
2988  }
2989  
2990  // RunCommandWithBodyWithResponse request with arbitrary body returning *RunCommandResponse
2991  func (c *ClientWithResponses) RunCommandWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RunCommandResponse, error) {
2992  	rsp, err := c.RunCommandWithBody(ctx, contentType, body, reqEditors...)
2993  	if err != nil {
2994  		return nil, err
2995  	}
2996  	return ParseRunCommandResponse(rsp)
2997  }
2998  
2999  func (c *ClientWithResponses) RunCommandWithResponse(ctx context.Context, body RunCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*RunCommandResponse, error) {
3000  	rsp, err := c.RunCommand(ctx, body, reqEditors...)
3001  	if err != nil {
3002  		return nil, err
3003  	}
3004  	return ParseRunCommandResponse(rsp)
3005  }
3006  
3007  // GetCommandStatusWithResponse request returning *GetCommandStatusResponse
3008  func (c *ClientWithResponses) GetCommandStatusWithResponse(ctx context.Context, id string, reqEditors ...RequestEditorFn) (*GetCommandStatusResponse, error) {
3009  	rsp, err := c.GetCommandStatus(ctx, id, reqEditors...)
3010  	if err != nil {
3011  		return nil, err
3012  	}
3013  	return ParseGetCommandStatusResponse(rsp)
3014  }
3015  
3016  // GetBackgroundCommandLogsWithResponse request returning *GetBackgroundCommandLogsResponse
3017  func (c *ClientWithResponses) GetBackgroundCommandLogsWithResponse(ctx context.Context, id string, params *GetBackgroundCommandLogsParams, reqEditors ...RequestEditorFn) (*GetBackgroundCommandLogsResponse, error) {
3018  	rsp, err := c.GetBackgroundCommandLogs(ctx, id, params, reqEditors...)
3019  	if err != nil {
3020  		return nil, err
3021  	}
3022  	return ParseGetBackgroundCommandLogsResponse(rsp)
3023  }
3024  
3025  // RemoveDirsWithResponse request returning *RemoveDirsResponse
3026  func (c *ClientWithResponses) RemoveDirsWithResponse(ctx context.Context, params *RemoveDirsParams, reqEditors ...RequestEditorFn) (*RemoveDirsResponse, error) {
3027  	rsp, err := c.RemoveDirs(ctx, params, reqEditors...)
3028  	if err != nil {
3029  		return nil, err
3030  	}
3031  	return ParseRemoveDirsResponse(rsp)
3032  }
3033  
3034  // MakeDirsWithBodyWithResponse request with arbitrary body returning *MakeDirsResponse
3035  func (c *ClientWithResponses) MakeDirsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*MakeDirsResponse, error) {
3036  	rsp, err := c.MakeDirsWithBody(ctx, contentType, body, reqEditors...)
3037  	if err != nil {
3038  		return nil, err
3039  	}
3040  	return ParseMakeDirsResponse(rsp)
3041  }
3042  
3043  func (c *ClientWithResponses) MakeDirsWithResponse(ctx context.Context, body MakeDirsJSONRequestBody, reqEditors ...RequestEditorFn) (*MakeDirsResponse, error) {
3044  	rsp, err := c.MakeDirs(ctx, body, reqEditors...)
3045  	if err != nil {
3046  		return nil, err
3047  	}
3048  	return ParseMakeDirsResponse(rsp)
3049  }
3050  
3051  // RemoveFilesWithResponse request returning *RemoveFilesResponse
3052  func (c *ClientWithResponses) RemoveFilesWithResponse(ctx context.Context, params *RemoveFilesParams, reqEditors ...RequestEditorFn) (*RemoveFilesResponse, error) {
3053  	rsp, err := c.RemoveFiles(ctx, params, reqEditors...)
3054  	if err != nil {
3055  		return nil, err
3056  	}
3057  	return ParseRemoveFilesResponse(rsp)
3058  }
3059  
3060  // DownloadFileWithResponse request returning *DownloadFileResponse
3061  func (c *ClientWithResponses) DownloadFileWithResponse(ctx context.Context, params *DownloadFileParams, reqEditors ...RequestEditorFn) (*DownloadFileResponse, error) {
3062  	rsp, err := c.DownloadFile(ctx, params, reqEditors...)
3063  	if err != nil {
3064  		return nil, err
3065  	}
3066  	return ParseDownloadFileResponse(rsp)
3067  }
3068  
3069  // GetFilesInfoWithResponse request returning *GetFilesInfoResponse
3070  func (c *ClientWithResponses) GetFilesInfoWithResponse(ctx context.Context, params *GetFilesInfoParams, reqEditors ...RequestEditorFn) (*GetFilesInfoResponse, error) {
3071  	rsp, err := c.GetFilesInfo(ctx, params, reqEditors...)
3072  	if err != nil {
3073  		return nil, err
3074  	}
3075  	return ParseGetFilesInfoResponse(rsp)
3076  }
3077  
3078  // RenameFilesWithBodyWithResponse request with arbitrary body returning *RenameFilesResponse
3079  func (c *ClientWithResponses) RenameFilesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RenameFilesResponse, error) {
3080  	rsp, err := c.RenameFilesWithBody(ctx, contentType, body, reqEditors...)
3081  	if err != nil {
3082  		return nil, err
3083  	}
3084  	return ParseRenameFilesResponse(rsp)
3085  }
3086  
3087  func (c *ClientWithResponses) RenameFilesWithResponse(ctx context.Context, body RenameFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*RenameFilesResponse, error) {
3088  	rsp, err := c.RenameFiles(ctx, body, reqEditors...)
3089  	if err != nil {
3090  		return nil, err
3091  	}
3092  	return ParseRenameFilesResponse(rsp)
3093  }
3094  
3095  // ChmodFilesWithBodyWithResponse request with arbitrary body returning *ChmodFilesResponse
3096  func (c *ClientWithResponses) ChmodFilesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ChmodFilesResponse, error) {
3097  	rsp, err := c.ChmodFilesWithBody(ctx, contentType, body, reqEditors...)
3098  	if err != nil {
3099  		return nil, err
3100  	}
3101  	return ParseChmodFilesResponse(rsp)
3102  }
3103  
3104  func (c *ClientWithResponses) ChmodFilesWithResponse(ctx context.Context, body ChmodFilesJSONRequestBody, reqEditors ...RequestEditorFn) (*ChmodFilesResponse, error) {
3105  	rsp, err := c.ChmodFiles(ctx, body, reqEditors...)
3106  	if err != nil {
3107  		return nil, err
3108  	}
3109  	return ParseChmodFilesResponse(rsp)
3110  }
3111  
3112  // ReplaceContentWithBodyWithResponse request with arbitrary body returning *ReplaceContentResponse
3113  func (c *ClientWithResponses) ReplaceContentWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ReplaceContentResponse, error) {
3114  	rsp, err := c.ReplaceContentWithBody(ctx, contentType, body, reqEditors...)
3115  	if err != nil {
3116  		return nil, err
3117  	}
3118  	return ParseReplaceContentResponse(rsp)
3119  }
3120  
3121  func (c *ClientWithResponses) ReplaceContentWithResponse(ctx context.Context, body ReplaceContentJSONRequestBody, reqEditors ...RequestEditorFn) (*ReplaceContentResponse, error) {
3122  	rsp, err := c.ReplaceContent(ctx, body, reqEditors...)
3123  	if err != nil {
3124  		return nil, err
3125  	}
3126  	return ParseReplaceContentResponse(rsp)
3127  }
3128  
3129  // SearchFilesWithResponse request returning *SearchFilesResponse
3130  func (c *ClientWithResponses) SearchFilesWithResponse(ctx context.Context, params *SearchFilesParams, reqEditors ...RequestEditorFn) (*SearchFilesResponse, error) {
3131  	rsp, err := c.SearchFiles(ctx, params, reqEditors...)
3132  	if err != nil {
3133  		return nil, err
3134  	}
3135  	return ParseSearchFilesResponse(rsp)
3136  }
3137  
3138  // UploadFileWithBodyWithResponse request with arbitrary body returning *UploadFileResponse
3139  func (c *ClientWithResponses) UploadFileWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UploadFileResponse, error) {
3140  	rsp, err := c.UploadFileWithBody(ctx, contentType, body, reqEditors...)
3141  	if err != nil {
3142  		return nil, err
3143  	}
3144  	return ParseUploadFileResponse(rsp)
3145  }
3146  
3147  // GetMetricsWithResponse request returning *GetMetricsResponse
3148  func (c *ClientWithResponses) GetMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetMetricsResponse, error) {
3149  	rsp, err := c.GetMetrics(ctx, reqEditors...)
3150  	if err != nil {
3151  		return nil, err
3152  	}
3153  	return ParseGetMetricsResponse(rsp)
3154  }
3155  
3156  // WatchMetricsWithResponse request returning *WatchMetricsResponse
3157  func (c *ClientWithResponses) WatchMetricsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*WatchMetricsResponse, error) {
3158  	rsp, err := c.WatchMetrics(ctx, reqEditors...)
3159  	if err != nil {
3160  		return nil, err
3161  	}
3162  	return ParseWatchMetricsResponse(rsp)
3163  }
3164  
3165  // PingWithResponse request returning *PingResponse
3166  func (c *ClientWithResponses) PingWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PingResponse, error) {
3167  	rsp, err := c.Ping(ctx, reqEditors...)
3168  	if err != nil {
3169  		return nil, err
3170  	}
3171  	return ParsePingResponse(rsp)
3172  }
3173  
3174  // CreateSessionWithBodyWithResponse request with arbitrary body returning *CreateSessionResponse
3175  func (c *ClientWithResponses) CreateSessionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateSessionResponse, error) {
3176  	rsp, err := c.CreateSessionWithBody(ctx, contentType, body, reqEditors...)
3177  	if err != nil {
3178  		return nil, err
3179  	}
3180  	return ParseCreateSessionResponse(rsp)
3181  }
3182  
3183  func (c *ClientWithResponses) CreateSessionWithResponse(ctx context.Context, body CreateSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateSessionResponse, error) {
3184  	rsp, err := c.CreateSession(ctx, body, reqEditors...)
3185  	if err != nil {
3186  		return nil, err
3187  	}
3188  	return ParseCreateSessionResponse(rsp)
3189  }
3190  
3191  // DeleteSessionWithResponse request returning *DeleteSessionResponse
3192  func (c *ClientWithResponses) DeleteSessionWithResponse(ctx context.Context, sessionID string, reqEditors ...RequestEditorFn) (*DeleteSessionResponse, error) {
3193  	rsp, err := c.DeleteSession(ctx, sessionID, reqEditors...)
3194  	if err != nil {
3195  		return nil, err
3196  	}
3197  	return ParseDeleteSessionResponse(rsp)
3198  }
3199  
3200  // RunInSessionWithBodyWithResponse request with arbitrary body returning *RunInSessionResponse
3201  func (c *ClientWithResponses) RunInSessionWithBodyWithResponse(ctx context.Context, sessionID string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RunInSessionResponse, error) {
3202  	rsp, err := c.RunInSessionWithBody(ctx, sessionID, contentType, body, reqEditors...)
3203  	if err != nil {
3204  		return nil, err
3205  	}
3206  	return ParseRunInSessionResponse(rsp)
3207  }
3208  
3209  func (c *ClientWithResponses) RunInSessionWithResponse(ctx context.Context, sessionID string, body RunInSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*RunInSessionResponse, error) {
3210  	rsp, err := c.RunInSession(ctx, sessionID, body, reqEditors...)
3211  	if err != nil {
3212  		return nil, err
3213  	}
3214  	return ParseRunInSessionResponse(rsp)
3215  }
3216  
3217  // ParseInterruptCodeResponse parses an HTTP response from a InterruptCodeWithResponse call
3218  func ParseInterruptCodeResponse(rsp *http.Response) (*InterruptCodeResponse, error) {
3219  	bodyBytes, err := io.ReadAll(rsp.Body)
3220  	defer func() { _ = rsp.Body.Close() }()
3221  	if err != nil {
3222  		return nil, err
3223  	}
3224  
3225  	response := &InterruptCodeResponse{
3226  		Body:         bodyBytes,
3227  		HTTPResponse: rsp,
3228  	}
3229  
3230  	switch {
3231  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3232  		var dest BadRequest
3233  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3234  			return nil, err
3235  		}
3236  		response.JSON400 = &dest
3237  
3238  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3239  		var dest InternalServerError
3240  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3241  			return nil, err
3242  		}
3243  		response.JSON500 = &dest
3244  
3245  	}
3246  
3247  	return response, nil
3248  }
3249  
3250  // ParseRunCodeResponse parses an HTTP response from a RunCodeWithResponse call
3251  func ParseRunCodeResponse(rsp *http.Response) (*RunCodeResponse, error) {
3252  	bodyBytes, err := io.ReadAll(rsp.Body)
3253  	defer func() { _ = rsp.Body.Close() }()
3254  	if err != nil {
3255  		return nil, err
3256  	}
3257  
3258  	response := &RunCodeResponse{
3259  		Body:         bodyBytes,
3260  		HTTPResponse: rsp,
3261  	}
3262  
3263  	switch {
3264  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3265  		var dest BadRequest
3266  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3267  			return nil, err
3268  		}
3269  		response.JSON400 = &dest
3270  
3271  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3272  		var dest InternalServerError
3273  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3274  			return nil, err
3275  		}
3276  		response.JSON500 = &dest
3277  
3278  	}
3279  
3280  	return response, nil
3281  }
3282  
3283  // ParseCreateCodeContextResponse parses an HTTP response from a CreateCodeContextWithResponse call
3284  func ParseCreateCodeContextResponse(rsp *http.Response) (*CreateCodeContextResponse, error) {
3285  	bodyBytes, err := io.ReadAll(rsp.Body)
3286  	defer func() { _ = rsp.Body.Close() }()
3287  	if err != nil {
3288  		return nil, err
3289  	}
3290  
3291  	response := &CreateCodeContextResponse{
3292  		Body:         bodyBytes,
3293  		HTTPResponse: rsp,
3294  	}
3295  
3296  	switch {
3297  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
3298  		var dest CodeContext
3299  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3300  			return nil, err
3301  		}
3302  		response.JSON200 = &dest
3303  
3304  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3305  		var dest BadRequest
3306  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3307  			return nil, err
3308  		}
3309  		response.JSON400 = &dest
3310  
3311  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3312  		var dest InternalServerError
3313  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3314  			return nil, err
3315  		}
3316  		response.JSON500 = &dest
3317  
3318  	}
3319  
3320  	return response, nil
3321  }
3322  
3323  // ParseDeleteContextsByLanguageResponse parses an HTTP response from a DeleteContextsByLanguageWithResponse call
3324  func ParseDeleteContextsByLanguageResponse(rsp *http.Response) (*DeleteContextsByLanguageResponse, error) {
3325  	bodyBytes, err := io.ReadAll(rsp.Body)
3326  	defer func() { _ = rsp.Body.Close() }()
3327  	if err != nil {
3328  		return nil, err
3329  	}
3330  
3331  	response := &DeleteContextsByLanguageResponse{
3332  		Body:         bodyBytes,
3333  		HTTPResponse: rsp,
3334  	}
3335  
3336  	switch {
3337  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3338  		var dest BadRequest
3339  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3340  			return nil, err
3341  		}
3342  		response.JSON400 = &dest
3343  
3344  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3345  		var dest InternalServerError
3346  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3347  			return nil, err
3348  		}
3349  		response.JSON500 = &dest
3350  
3351  	}
3352  
3353  	return response, nil
3354  }
3355  
3356  // ParseListContextsResponse parses an HTTP response from a ListContextsWithResponse call
3357  func ParseListContextsResponse(rsp *http.Response) (*ListContextsResponse, error) {
3358  	bodyBytes, err := io.ReadAll(rsp.Body)
3359  	defer func() { _ = rsp.Body.Close() }()
3360  	if err != nil {
3361  		return nil, err
3362  	}
3363  
3364  	response := &ListContextsResponse{
3365  		Body:         bodyBytes,
3366  		HTTPResponse: rsp,
3367  	}
3368  
3369  	switch {
3370  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
3371  		var dest []CodeContext
3372  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3373  			return nil, err
3374  		}
3375  		response.JSON200 = &dest
3376  
3377  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3378  		var dest BadRequest
3379  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3380  			return nil, err
3381  		}
3382  		response.JSON400 = &dest
3383  
3384  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3385  		var dest InternalServerError
3386  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3387  			return nil, err
3388  		}
3389  		response.JSON500 = &dest
3390  
3391  	}
3392  
3393  	return response, nil
3394  }
3395  
3396  // ParseDeleteContextResponse parses an HTTP response from a DeleteContextWithResponse call
3397  func ParseDeleteContextResponse(rsp *http.Response) (*DeleteContextResponse, error) {
3398  	bodyBytes, err := io.ReadAll(rsp.Body)
3399  	defer func() { _ = rsp.Body.Close() }()
3400  	if err != nil {
3401  		return nil, err
3402  	}
3403  
3404  	response := &DeleteContextResponse{
3405  		Body:         bodyBytes,
3406  		HTTPResponse: rsp,
3407  	}
3408  
3409  	switch {
3410  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3411  		var dest BadRequest
3412  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3413  			return nil, err
3414  		}
3415  		response.JSON400 = &dest
3416  
3417  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3418  		var dest NotFound
3419  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3420  			return nil, err
3421  		}
3422  		response.JSON404 = &dest
3423  
3424  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3425  		var dest InternalServerError
3426  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3427  			return nil, err
3428  		}
3429  		response.JSON500 = &dest
3430  
3431  	}
3432  
3433  	return response, nil
3434  }
3435  
3436  // ParseGetContextResponse parses an HTTP response from a GetContextWithResponse call
3437  func ParseGetContextResponse(rsp *http.Response) (*GetContextResponse, error) {
3438  	bodyBytes, err := io.ReadAll(rsp.Body)
3439  	defer func() { _ = rsp.Body.Close() }()
3440  	if err != nil {
3441  		return nil, err
3442  	}
3443  
3444  	response := &GetContextResponse{
3445  		Body:         bodyBytes,
3446  		HTTPResponse: rsp,
3447  	}
3448  
3449  	switch {
3450  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
3451  		var dest CodeContext
3452  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3453  			return nil, err
3454  		}
3455  		response.JSON200 = &dest
3456  
3457  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3458  		var dest NotFound
3459  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3460  			return nil, err
3461  		}
3462  		response.JSON404 = &dest
3463  
3464  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3465  		var dest InternalServerError
3466  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3467  			return nil, err
3468  		}
3469  		response.JSON500 = &dest
3470  
3471  	}
3472  
3473  	return response, nil
3474  }
3475  
3476  // ParseInterruptCommandResponse parses an HTTP response from a InterruptCommandWithResponse call
3477  func ParseInterruptCommandResponse(rsp *http.Response) (*InterruptCommandResponse, error) {
3478  	bodyBytes, err := io.ReadAll(rsp.Body)
3479  	defer func() { _ = rsp.Body.Close() }()
3480  	if err != nil {
3481  		return nil, err
3482  	}
3483  
3484  	response := &InterruptCommandResponse{
3485  		Body:         bodyBytes,
3486  		HTTPResponse: rsp,
3487  	}
3488  
3489  	switch {
3490  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3491  		var dest BadRequest
3492  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3493  			return nil, err
3494  		}
3495  		response.JSON400 = &dest
3496  
3497  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3498  		var dest InternalServerError
3499  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3500  			return nil, err
3501  		}
3502  		response.JSON500 = &dest
3503  
3504  	}
3505  
3506  	return response, nil
3507  }
3508  
3509  // ParseRunCommandResponse parses an HTTP response from a RunCommandWithResponse call
3510  func ParseRunCommandResponse(rsp *http.Response) (*RunCommandResponse, error) {
3511  	bodyBytes, err := io.ReadAll(rsp.Body)
3512  	defer func() { _ = rsp.Body.Close() }()
3513  	if err != nil {
3514  		return nil, err
3515  	}
3516  
3517  	response := &RunCommandResponse{
3518  		Body:         bodyBytes,
3519  		HTTPResponse: rsp,
3520  	}
3521  
3522  	switch {
3523  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3524  		var dest BadRequest
3525  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3526  			return nil, err
3527  		}
3528  		response.JSON400 = &dest
3529  
3530  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3531  		var dest InternalServerError
3532  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3533  			return nil, err
3534  		}
3535  		response.JSON500 = &dest
3536  
3537  	}
3538  
3539  	return response, nil
3540  }
3541  
3542  // ParseGetCommandStatusResponse parses an HTTP response from a GetCommandStatusWithResponse call
3543  func ParseGetCommandStatusResponse(rsp *http.Response) (*GetCommandStatusResponse, error) {
3544  	bodyBytes, err := io.ReadAll(rsp.Body)
3545  	defer func() { _ = rsp.Body.Close() }()
3546  	if err != nil {
3547  		return nil, err
3548  	}
3549  
3550  	response := &GetCommandStatusResponse{
3551  		Body:         bodyBytes,
3552  		HTTPResponse: rsp,
3553  	}
3554  
3555  	switch {
3556  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
3557  		var dest CommandStatusResponse
3558  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3559  			return nil, err
3560  		}
3561  		response.JSON200 = &dest
3562  
3563  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3564  		var dest BadRequest
3565  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3566  			return nil, err
3567  		}
3568  		response.JSON400 = &dest
3569  
3570  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3571  		var dest NotFound
3572  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3573  			return nil, err
3574  		}
3575  		response.JSON404 = &dest
3576  
3577  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3578  		var dest InternalServerError
3579  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3580  			return nil, err
3581  		}
3582  		response.JSON500 = &dest
3583  
3584  	}
3585  
3586  	return response, nil
3587  }
3588  
3589  // ParseGetBackgroundCommandLogsResponse parses an HTTP response from a GetBackgroundCommandLogsWithResponse call
3590  func ParseGetBackgroundCommandLogsResponse(rsp *http.Response) (*GetBackgroundCommandLogsResponse, error) {
3591  	bodyBytes, err := io.ReadAll(rsp.Body)
3592  	defer func() { _ = rsp.Body.Close() }()
3593  	if err != nil {
3594  		return nil, err
3595  	}
3596  
3597  	response := &GetBackgroundCommandLogsResponse{
3598  		Body:         bodyBytes,
3599  		HTTPResponse: rsp,
3600  	}
3601  
3602  	switch {
3603  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3604  		var dest BadRequest
3605  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3606  			return nil, err
3607  		}
3608  		response.JSON400 = &dest
3609  
3610  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3611  		var dest NotFound
3612  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3613  			return nil, err
3614  		}
3615  		response.JSON404 = &dest
3616  
3617  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3618  		var dest InternalServerError
3619  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3620  			return nil, err
3621  		}
3622  		response.JSON500 = &dest
3623  
3624  	}
3625  
3626  	return response, nil
3627  }
3628  
3629  // ParseRemoveDirsResponse parses an HTTP response from a RemoveDirsWithResponse call
3630  func ParseRemoveDirsResponse(rsp *http.Response) (*RemoveDirsResponse, error) {
3631  	bodyBytes, err := io.ReadAll(rsp.Body)
3632  	defer func() { _ = rsp.Body.Close() }()
3633  	if err != nil {
3634  		return nil, err
3635  	}
3636  
3637  	response := &RemoveDirsResponse{
3638  		Body:         bodyBytes,
3639  		HTTPResponse: rsp,
3640  	}
3641  
3642  	switch {
3643  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3644  		var dest InternalServerError
3645  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3646  			return nil, err
3647  		}
3648  		response.JSON500 = &dest
3649  
3650  	}
3651  
3652  	return response, nil
3653  }
3654  
3655  // ParseMakeDirsResponse parses an HTTP response from a MakeDirsWithResponse call
3656  func ParseMakeDirsResponse(rsp *http.Response) (*MakeDirsResponse, error) {
3657  	bodyBytes, err := io.ReadAll(rsp.Body)
3658  	defer func() { _ = rsp.Body.Close() }()
3659  	if err != nil {
3660  		return nil, err
3661  	}
3662  
3663  	response := &MakeDirsResponse{
3664  		Body:         bodyBytes,
3665  		HTTPResponse: rsp,
3666  	}
3667  
3668  	switch {
3669  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3670  		var dest BadRequest
3671  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3672  			return nil, err
3673  		}
3674  		response.JSON400 = &dest
3675  
3676  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3677  		var dest InternalServerError
3678  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3679  			return nil, err
3680  		}
3681  		response.JSON500 = &dest
3682  
3683  	}
3684  
3685  	return response, nil
3686  }
3687  
3688  // ParseRemoveFilesResponse parses an HTTP response from a RemoveFilesWithResponse call
3689  func ParseRemoveFilesResponse(rsp *http.Response) (*RemoveFilesResponse, error) {
3690  	bodyBytes, err := io.ReadAll(rsp.Body)
3691  	defer func() { _ = rsp.Body.Close() }()
3692  	if err != nil {
3693  		return nil, err
3694  	}
3695  
3696  	response := &RemoveFilesResponse{
3697  		Body:         bodyBytes,
3698  		HTTPResponse: rsp,
3699  	}
3700  
3701  	switch {
3702  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3703  		var dest InternalServerError
3704  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3705  			return nil, err
3706  		}
3707  		response.JSON500 = &dest
3708  
3709  	}
3710  
3711  	return response, nil
3712  }
3713  
3714  // ParseDownloadFileResponse parses an HTTP response from a DownloadFileWithResponse call
3715  func ParseDownloadFileResponse(rsp *http.Response) (*DownloadFileResponse, error) {
3716  	bodyBytes, err := io.ReadAll(rsp.Body)
3717  	defer func() { _ = rsp.Body.Close() }()
3718  	if err != nil {
3719  		return nil, err
3720  	}
3721  
3722  	response := &DownloadFileResponse{
3723  		Body:         bodyBytes,
3724  		HTTPResponse: rsp,
3725  	}
3726  
3727  	switch {
3728  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3729  		var dest BadRequest
3730  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3731  			return nil, err
3732  		}
3733  		response.JSON400 = &dest
3734  
3735  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3736  		var dest NotFound
3737  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3738  			return nil, err
3739  		}
3740  		response.JSON404 = &dest
3741  
3742  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 416:
3743  		var dest ErrorResponse
3744  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3745  			return nil, err
3746  		}
3747  		response.JSON416 = &dest
3748  
3749  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3750  		var dest InternalServerError
3751  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3752  			return nil, err
3753  		}
3754  		response.JSON500 = &dest
3755  
3756  	}
3757  
3758  	return response, nil
3759  }
3760  
3761  // ParseGetFilesInfoResponse parses an HTTP response from a GetFilesInfoWithResponse call
3762  func ParseGetFilesInfoResponse(rsp *http.Response) (*GetFilesInfoResponse, error) {
3763  	bodyBytes, err := io.ReadAll(rsp.Body)
3764  	defer func() { _ = rsp.Body.Close() }()
3765  	if err != nil {
3766  		return nil, err
3767  	}
3768  
3769  	response := &GetFilesInfoResponse{
3770  		Body:         bodyBytes,
3771  		HTTPResponse: rsp,
3772  	}
3773  
3774  	switch {
3775  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
3776  		var dest map[string]FileInfo
3777  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3778  			return nil, err
3779  		}
3780  		response.JSON200 = &dest
3781  
3782  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3783  		var dest NotFound
3784  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3785  			return nil, err
3786  		}
3787  		response.JSON404 = &dest
3788  
3789  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3790  		var dest InternalServerError
3791  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3792  			return nil, err
3793  		}
3794  		response.JSON500 = &dest
3795  
3796  	}
3797  
3798  	return response, nil
3799  }
3800  
3801  // ParseRenameFilesResponse parses an HTTP response from a RenameFilesWithResponse call
3802  func ParseRenameFilesResponse(rsp *http.Response) (*RenameFilesResponse, error) {
3803  	bodyBytes, err := io.ReadAll(rsp.Body)
3804  	defer func() { _ = rsp.Body.Close() }()
3805  	if err != nil {
3806  		return nil, err
3807  	}
3808  
3809  	response := &RenameFilesResponse{
3810  		Body:         bodyBytes,
3811  		HTTPResponse: rsp,
3812  	}
3813  
3814  	switch {
3815  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3816  		var dest BadRequest
3817  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3818  			return nil, err
3819  		}
3820  		response.JSON400 = &dest
3821  
3822  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3823  		var dest NotFound
3824  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3825  			return nil, err
3826  		}
3827  		response.JSON404 = &dest
3828  
3829  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3830  		var dest InternalServerError
3831  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3832  			return nil, err
3833  		}
3834  		response.JSON500 = &dest
3835  
3836  	}
3837  
3838  	return response, nil
3839  }
3840  
3841  // ParseChmodFilesResponse parses an HTTP response from a ChmodFilesWithResponse call
3842  func ParseChmodFilesResponse(rsp *http.Response) (*ChmodFilesResponse, error) {
3843  	bodyBytes, err := io.ReadAll(rsp.Body)
3844  	defer func() { _ = rsp.Body.Close() }()
3845  	if err != nil {
3846  		return nil, err
3847  	}
3848  
3849  	response := &ChmodFilesResponse{
3850  		Body:         bodyBytes,
3851  		HTTPResponse: rsp,
3852  	}
3853  
3854  	switch {
3855  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3856  		var dest BadRequest
3857  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3858  			return nil, err
3859  		}
3860  		response.JSON400 = &dest
3861  
3862  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3863  		var dest InternalServerError
3864  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3865  			return nil, err
3866  		}
3867  		response.JSON500 = &dest
3868  
3869  	}
3870  
3871  	return response, nil
3872  }
3873  
3874  // ParseReplaceContentResponse parses an HTTP response from a ReplaceContentWithResponse call
3875  func ParseReplaceContentResponse(rsp *http.Response) (*ReplaceContentResponse, error) {
3876  	bodyBytes, err := io.ReadAll(rsp.Body)
3877  	defer func() { _ = rsp.Body.Close() }()
3878  	if err != nil {
3879  		return nil, err
3880  	}
3881  
3882  	response := &ReplaceContentResponse{
3883  		Body:         bodyBytes,
3884  		HTTPResponse: rsp,
3885  	}
3886  
3887  	switch {
3888  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3889  		var dest BadRequest
3890  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3891  			return nil, err
3892  		}
3893  		response.JSON400 = &dest
3894  
3895  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3896  		var dest InternalServerError
3897  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3898  			return nil, err
3899  		}
3900  		response.JSON500 = &dest
3901  
3902  	}
3903  
3904  	return response, nil
3905  }
3906  
3907  // ParseSearchFilesResponse parses an HTTP response from a SearchFilesWithResponse call
3908  func ParseSearchFilesResponse(rsp *http.Response) (*SearchFilesResponse, error) {
3909  	bodyBytes, err := io.ReadAll(rsp.Body)
3910  	defer func() { _ = rsp.Body.Close() }()
3911  	if err != nil {
3912  		return nil, err
3913  	}
3914  
3915  	response := &SearchFilesResponse{
3916  		Body:         bodyBytes,
3917  		HTTPResponse: rsp,
3918  	}
3919  
3920  	switch {
3921  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
3922  		var dest []FileInfo
3923  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3924  			return nil, err
3925  		}
3926  		response.JSON200 = &dest
3927  
3928  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3929  		var dest BadRequest
3930  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3931  			return nil, err
3932  		}
3933  		response.JSON400 = &dest
3934  
3935  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
3936  		var dest NotFound
3937  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3938  			return nil, err
3939  		}
3940  		response.JSON404 = &dest
3941  
3942  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3943  		var dest InternalServerError
3944  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3945  			return nil, err
3946  		}
3947  		response.JSON500 = &dest
3948  
3949  	}
3950  
3951  	return response, nil
3952  }
3953  
3954  // ParseUploadFileResponse parses an HTTP response from a UploadFileWithResponse call
3955  func ParseUploadFileResponse(rsp *http.Response) (*UploadFileResponse, error) {
3956  	bodyBytes, err := io.ReadAll(rsp.Body)
3957  	defer func() { _ = rsp.Body.Close() }()
3958  	if err != nil {
3959  		return nil, err
3960  	}
3961  
3962  	response := &UploadFileResponse{
3963  		Body:         bodyBytes,
3964  		HTTPResponse: rsp,
3965  	}
3966  
3967  	switch {
3968  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
3969  		var dest BadRequest
3970  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3971  			return nil, err
3972  		}
3973  		response.JSON400 = &dest
3974  
3975  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
3976  		var dest InternalServerError
3977  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
3978  			return nil, err
3979  		}
3980  		response.JSON500 = &dest
3981  
3982  	}
3983  
3984  	return response, nil
3985  }
3986  
3987  // ParseGetMetricsResponse parses an HTTP response from a GetMetricsWithResponse call
3988  func ParseGetMetricsResponse(rsp *http.Response) (*GetMetricsResponse, error) {
3989  	bodyBytes, err := io.ReadAll(rsp.Body)
3990  	defer func() { _ = rsp.Body.Close() }()
3991  	if err != nil {
3992  		return nil, err
3993  	}
3994  
3995  	response := &GetMetricsResponse{
3996  		Body:         bodyBytes,
3997  		HTTPResponse: rsp,
3998  	}
3999  
4000  	switch {
4001  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
4002  		var dest Metrics
4003  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4004  			return nil, err
4005  		}
4006  		response.JSON200 = &dest
4007  
4008  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
4009  		var dest InternalServerError
4010  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4011  			return nil, err
4012  		}
4013  		response.JSON500 = &dest
4014  
4015  	}
4016  
4017  	return response, nil
4018  }
4019  
4020  // ParseWatchMetricsResponse parses an HTTP response from a WatchMetricsWithResponse call
4021  func ParseWatchMetricsResponse(rsp *http.Response) (*WatchMetricsResponse, error) {
4022  	bodyBytes, err := io.ReadAll(rsp.Body)
4023  	defer func() { _ = rsp.Body.Close() }()
4024  	if err != nil {
4025  		return nil, err
4026  	}
4027  
4028  	response := &WatchMetricsResponse{
4029  		Body:         bodyBytes,
4030  		HTTPResponse: rsp,
4031  	}
4032  
4033  	switch {
4034  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
4035  		var dest InternalServerError
4036  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4037  			return nil, err
4038  		}
4039  		response.JSON500 = &dest
4040  
4041  	}
4042  
4043  	return response, nil
4044  }
4045  
4046  // ParsePingResponse parses an HTTP response from a PingWithResponse call
4047  func ParsePingResponse(rsp *http.Response) (*PingResponse, error) {
4048  	bodyBytes, err := io.ReadAll(rsp.Body)
4049  	defer func() { _ = rsp.Body.Close() }()
4050  	if err != nil {
4051  		return nil, err
4052  	}
4053  
4054  	response := &PingResponse{
4055  		Body:         bodyBytes,
4056  		HTTPResponse: rsp,
4057  	}
4058  
4059  	return response, nil
4060  }
4061  
4062  // ParseCreateSessionResponse parses an HTTP response from a CreateSessionWithResponse call
4063  func ParseCreateSessionResponse(rsp *http.Response) (*CreateSessionResponse, error) {
4064  	bodyBytes, err := io.ReadAll(rsp.Body)
4065  	defer func() { _ = rsp.Body.Close() }()
4066  	if err != nil {
4067  		return nil, err
4068  	}
4069  
4070  	response := &CreateSessionResponse{
4071  		Body:         bodyBytes,
4072  		HTTPResponse: rsp,
4073  	}
4074  
4075  	switch {
4076  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
4077  		var dest SessionCreated
4078  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4079  			return nil, err
4080  		}
4081  		response.JSON200 = &dest
4082  
4083  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
4084  		var dest BadRequest
4085  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4086  			return nil, err
4087  		}
4088  		response.JSON400 = &dest
4089  
4090  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
4091  		var dest InternalServerError
4092  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4093  			return nil, err
4094  		}
4095  		response.JSON500 = &dest
4096  
4097  	}
4098  
4099  	return response, nil
4100  }
4101  
4102  // ParseDeleteSessionResponse parses an HTTP response from a DeleteSessionWithResponse call
4103  func ParseDeleteSessionResponse(rsp *http.Response) (*DeleteSessionResponse, error) {
4104  	bodyBytes, err := io.ReadAll(rsp.Body)
4105  	defer func() { _ = rsp.Body.Close() }()
4106  	if err != nil {
4107  		return nil, err
4108  	}
4109  
4110  	response := &DeleteSessionResponse{
4111  		Body:         bodyBytes,
4112  		HTTPResponse: rsp,
4113  	}
4114  
4115  	switch {
4116  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
4117  		var dest BadRequest
4118  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4119  			return nil, err
4120  		}
4121  		response.JSON400 = &dest
4122  
4123  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
4124  		var dest NotFound
4125  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4126  			return nil, err
4127  		}
4128  		response.JSON404 = &dest
4129  
4130  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
4131  		var dest InternalServerError
4132  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4133  			return nil, err
4134  		}
4135  		response.JSON500 = &dest
4136  
4137  	}
4138  
4139  	return response, nil
4140  }
4141  
4142  // ParseRunInSessionResponse parses an HTTP response from a RunInSessionWithResponse call
4143  func ParseRunInSessionResponse(rsp *http.Response) (*RunInSessionResponse, error) {
4144  	bodyBytes, err := io.ReadAll(rsp.Body)
4145  	defer func() { _ = rsp.Body.Close() }()
4146  	if err != nil {
4147  		return nil, err
4148  	}
4149  
4150  	response := &RunInSessionResponse{
4151  		Body:         bodyBytes,
4152  		HTTPResponse: rsp,
4153  	}
4154  
4155  	switch {
4156  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
4157  		var dest BadRequest
4158  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4159  			return nil, err
4160  		}
4161  		response.JSON400 = &dest
4162  
4163  	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500:
4164  		var dest InternalServerError
4165  		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
4166  			return nil, err
4167  		}
4168  		response.JSON500 = &dest
4169  
4170  	}
4171  
4172  	return response, nil
4173  }