go-base/sdk/opencode/opencode_api_client.gen.go

// Package opencode provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.5.1 DO NOT EDIT.
package opencode

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"


// RequestEditorFn  is the function signature for the RequestEditor callback function
type RequestEditorFn func(ctx context.Context, req *http.Request) error

// Doer performs HTTP requests.
//
// The standard http.Client implements this interface.
type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

// Client which conforms to the OpenAPI3 specification for this service.
type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

// ClientOption allows setting custom parameters during construction
type ClientOption func(*Client) error

// Creates a new Client, with reasonable defaults
func NewClient(server string, opts ...ClientOption) (*Client, error) {
	// create a client with sane default values
	client := Client{
		Server: server,
	}
	// mutate client and add all optional params
	for _, o := range opts {
		if err := o(&client); err != nil {
			return nil, err
		}
	}
	// ensure the server URL always has a trailing slash
	if !strings.HasSuffix(client.Server, "/") {
		client.Server += "/"
	}
	// create httpClient, if not already present
	if client.Client == nil {
		client.Client = &http.Client{}
	}
	return &client, nil
}

// WithHTTPClient allows overriding the default Doer, which is
// automatically created using http.Client. This is useful for tests.
func WithHTTPClient(doer HttpRequestDoer) ClientOption {
	return func(c *Client) error {
		c.Client = doer
		return nil
	}
}

// WithRequestEditorFn allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
	return func(c *Client) error {
		c.RequestEditors = append(c.RequestEditors, fn)
		return nil
	}
}

// The interface specification for the client above.
type ClientInterface interface {
	// AppAgents request
	AppAgents(ctx context.Context, params *AppAgentsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AuthSetWithBody request with any body
	AuthSetWithBody(ctx context.Context, providerID string, params *AuthSetParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AuthSet(ctx context.Context, providerID string, params *AuthSetParams, body AuthSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CommandList request
	CommandList(ctx context.Context, params *CommandListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ConfigGet request
	ConfigGet(ctx context.Context, params *ConfigGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ConfigUpdateWithBody request with any body
	ConfigUpdateWithBody(ctx context.Context, params *ConfigUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ConfigUpdate(ctx context.Context, params *ConfigUpdateParams, body ConfigUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ConfigProviders request
	ConfigProviders(ctx context.Context, params *ConfigProvidersParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// EventSubscribe request
	EventSubscribe(ctx context.Context, params *EventSubscribeParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ExperimentalResourceList request
	ExperimentalResourceList(ctx context.Context, params *ExperimentalResourceListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ToolList request
	ToolList(ctx context.Context, params *ToolListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ToolIds request
	ToolIds(ctx context.Context, params *ToolIdsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// WorktreeList request
	WorktreeList(ctx context.Context, params *WorktreeListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// WorktreeCreateWithBody request with any body
	WorktreeCreateWithBody(ctx context.Context, params *WorktreeCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	WorktreeCreate(ctx context.Context, params *WorktreeCreateParams, body WorktreeCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FileList request
	FileList(ctx context.Context, params *FileListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FileRead request
	FileRead(ctx context.Context, params *FileReadParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FileStatus request
	FileStatus(ctx context.Context, params *FileStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindText request
	FindText(ctx context.Context, params *FindTextParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindFiles request
	FindFiles(ctx context.Context, params *FindFilesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FindSymbols request
	FindSymbols(ctx context.Context, params *FindSymbolsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// FormatterStatus request
	FormatterStatus(ctx context.Context, params *FormatterStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GlobalDispose request
	GlobalDispose(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GlobalEvent request
	GlobalEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GlobalHealth request
	GlobalHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// InstanceDispose request
	InstanceDispose(ctx context.Context, params *InstanceDisposeParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// AppLogWithBody request with any body
	AppLogWithBody(ctx context.Context, params *AppLogParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	AppLog(ctx context.Context, params *AppLogParams, body AppLogJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// LspStatus request
	LspStatus(ctx context.Context, params *LspStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpStatus request
	McpStatus(ctx context.Context, params *McpStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpAddWithBody request with any body
	McpAddWithBody(ctx context.Context, params *McpAddParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	McpAdd(ctx context.Context, params *McpAddParams, body McpAddJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpAuthRemove request
	McpAuthRemove(ctx context.Context, name string, params *McpAuthRemoveParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpAuthStart request
	McpAuthStart(ctx context.Context, name string, params *McpAuthStartParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpAuthAuthenticate request
	McpAuthAuthenticate(ctx context.Context, name string, params *McpAuthAuthenticateParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpAuthCallbackWithBody request with any body
	McpAuthCallbackWithBody(ctx context.Context, name string, params *McpAuthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	McpAuthCallback(ctx context.Context, name string, params *McpAuthCallbackParams, body McpAuthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpConnect request
	McpConnect(ctx context.Context, name string, params *McpConnectParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// McpDisconnect request
	McpDisconnect(ctx context.Context, name string, params *McpDisconnectParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PathGet request
	PathGet(ctx context.Context, params *PathGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PermissionList request
	PermissionList(ctx context.Context, params *PermissionListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PermissionReplyWithBody request with any body
	PermissionReplyWithBody(ctx context.Context, requestID string, params *PermissionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PermissionReply(ctx context.Context, requestID string, params *PermissionReplyParams, body PermissionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProjectList request
	ProjectList(ctx context.Context, params *ProjectListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProjectCurrent request
	ProjectCurrent(ctx context.Context, params *ProjectCurrentParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProjectUpdateWithBody request with any body
	ProjectUpdateWithBody(ctx context.Context, projectID string, params *ProjectUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ProjectUpdate(ctx context.Context, projectID string, params *ProjectUpdateParams, body ProjectUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProviderList request
	ProviderList(ctx context.Context, params *ProviderListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProviderAuth request
	ProviderAuth(ctx context.Context, params *ProviderAuthParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProviderOauthAuthorizeWithBody request with any body
	ProviderOauthAuthorizeWithBody(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ProviderOauthAuthorize(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, body ProviderOauthAuthorizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ProviderOauthCallbackWithBody request with any body
	ProviderOauthCallbackWithBody(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	ProviderOauthCallback(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, body ProviderOauthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PtyList request
	PtyList(ctx context.Context, params *PtyListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PtyCreateWithBody request with any body
	PtyCreateWithBody(ctx context.Context, params *PtyCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PtyCreate(ctx context.Context, params *PtyCreateParams, body PtyCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PtyRemove request
	PtyRemove(ctx context.Context, ptyID string, params *PtyRemoveParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PtyGet request
	PtyGet(ctx context.Context, ptyID string, params *PtyGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PtyUpdateWithBody request with any body
	PtyUpdateWithBody(ctx context.Context, ptyID string, params *PtyUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PtyUpdate(ctx context.Context, ptyID string, params *PtyUpdateParams, body PtyUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PtyConnect request
	PtyConnect(ctx context.Context, ptyID string, params *PtyConnectParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// QuestionList request
	QuestionList(ctx context.Context, params *QuestionListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// QuestionReject request
	QuestionReject(ctx context.Context, requestID string, params *QuestionRejectParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// QuestionReplyWithBody request with any body
	QuestionReplyWithBody(ctx context.Context, requestID string, params *QuestionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	QuestionReply(ctx context.Context, requestID string, params *QuestionReplyParams, body QuestionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionList request
	SessionList(ctx context.Context, params *SessionListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionCreateWithBody request with any body
	SessionCreateWithBody(ctx context.Context, params *SessionCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionCreate(ctx context.Context, params *SessionCreateParams, body SessionCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionStatus request
	SessionStatus(ctx context.Context, params *SessionStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionDelete request
	SessionDelete(ctx context.Context, sessionID string, params *SessionDeleteParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionGet request
	SessionGet(ctx context.Context, sessionID string, params *SessionGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionUpdateWithBody request with any body
	SessionUpdateWithBody(ctx context.Context, sessionID string, params *SessionUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionUpdate(ctx context.Context, sessionID string, params *SessionUpdateParams, body SessionUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionAbort request
	SessionAbort(ctx context.Context, sessionID string, params *SessionAbortParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionChildren request
	SessionChildren(ctx context.Context, sessionID string, params *SessionChildrenParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionCommandWithBody request with any body
	SessionCommandWithBody(ctx context.Context, sessionID string, params *SessionCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionCommand(ctx context.Context, sessionID string, params *SessionCommandParams, body SessionCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionDiff request
	SessionDiff(ctx context.Context, sessionID string, params *SessionDiffParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionForkWithBody request with any body
	SessionForkWithBody(ctx context.Context, sessionID string, params *SessionForkParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionFork(ctx context.Context, sessionID string, params *SessionForkParams, body SessionForkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionInitWithBody request with any body
	SessionInitWithBody(ctx context.Context, sessionID string, params *SessionInitParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionInit(ctx context.Context, sessionID string, params *SessionInitParams, body SessionInitJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionMessages request
	SessionMessages(ctx context.Context, sessionID string, params *SessionMessagesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionPromptWithBody request with any body
	SessionPromptWithBody(ctx context.Context, sessionID string, params *SessionPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionPrompt(ctx context.Context, sessionID string, params *SessionPromptParams, body SessionPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionMessage request
	SessionMessage(ctx context.Context, sessionID string, messageID string, params *SessionMessageParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PartDelete request
	PartDelete(ctx context.Context, sessionID string, messageID string, partID string, params *PartDeleteParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PartUpdateWithBody request with any body
	PartUpdateWithBody(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PartUpdate(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, body PartUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PermissionRespondWithBody request with any body
	PermissionRespondWithBody(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	PermissionRespond(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, body PermissionRespondJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionPromptAsyncWithBody request with any body
	SessionPromptAsyncWithBody(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionPromptAsync(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, body SessionPromptAsyncJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionRevertWithBody request with any body
	SessionRevertWithBody(ctx context.Context, sessionID string, params *SessionRevertParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionRevert(ctx context.Context, sessionID string, params *SessionRevertParams, body SessionRevertJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionUnshare request
	SessionUnshare(ctx context.Context, sessionID string, params *SessionUnshareParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionShare request
	SessionShare(ctx context.Context, sessionID string, params *SessionShareParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionShellWithBody request with any body
	SessionShellWithBody(ctx context.Context, sessionID string, params *SessionShellParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionShell(ctx context.Context, sessionID string, params *SessionShellParams, body SessionShellJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionSummarizeWithBody request with any body
	SessionSummarizeWithBody(ctx context.Context, sessionID string, params *SessionSummarizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	SessionSummarize(ctx context.Context, sessionID string, params *SessionSummarizeParams, body SessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionTodo request
	SessionTodo(ctx context.Context, sessionID string, params *SessionTodoParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SessionUnrevert request
	SessionUnrevert(ctx context.Context, sessionID string, params *SessionUnrevertParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiAppendPromptWithBody request with any body
	TuiAppendPromptWithBody(ctx context.Context, params *TuiAppendPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	TuiAppendPrompt(ctx context.Context, params *TuiAppendPromptParams, body TuiAppendPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiClearPrompt request
	TuiClearPrompt(ctx context.Context, params *TuiClearPromptParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiControlNext request
	TuiControlNext(ctx context.Context, params *TuiControlNextParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiControlResponseWithBody request with any body
	TuiControlResponseWithBody(ctx context.Context, params *TuiControlResponseParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	TuiControlResponse(ctx context.Context, params *TuiControlResponseParams, body TuiControlResponseJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiExecuteCommandWithBody request with any body
	TuiExecuteCommandWithBody(ctx context.Context, params *TuiExecuteCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	TuiExecuteCommand(ctx context.Context, params *TuiExecuteCommandParams, body TuiExecuteCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiOpenHelp request
	TuiOpenHelp(ctx context.Context, params *TuiOpenHelpParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiOpenModels request
	TuiOpenModels(ctx context.Context, params *TuiOpenModelsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiOpenSessions request
	TuiOpenSessions(ctx context.Context, params *TuiOpenSessionsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiOpenThemes request
	TuiOpenThemes(ctx context.Context, params *TuiOpenThemesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiPublishWithBody request with any body
	TuiPublishWithBody(ctx context.Context, params *TuiPublishParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	TuiPublish(ctx context.Context, params *TuiPublishParams, body TuiPublishJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiSelectSessionWithBody request with any body
	TuiSelectSessionWithBody(ctx context.Context, params *TuiSelectSessionParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	TuiSelectSession(ctx context.Context, params *TuiSelectSessionParams, body TuiSelectSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiShowToastWithBody request with any body
	TuiShowToastWithBody(ctx context.Context, params *TuiShowToastParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	TuiShowToast(ctx context.Context, params *TuiShowToastParams, body TuiShowToastJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// TuiSubmitPrompt request
	TuiSubmitPrompt(ctx context.Context, params *TuiSubmitPromptParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// VcsGet request
	VcsGet(ctx context.Context, params *VcsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) AppAgents(ctx context.Context, params *AppAgentsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAppAgentsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AuthSetWithBody(ctx context.Context, providerID string, params *AuthSetParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAuthSetRequestWithBody(c.Server, providerID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AuthSet(ctx context.Context, providerID string, params *AuthSetParams, body AuthSetJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAuthSetRequest(c.Server, providerID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) CommandList(ctx context.Context, params *CommandListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewCommandListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ConfigGet(ctx context.Context, params *ConfigGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewConfigGetRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ConfigUpdateWithBody(ctx context.Context, params *ConfigUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewConfigUpdateRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ConfigUpdate(ctx context.Context, params *ConfigUpdateParams, body ConfigUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewConfigUpdateRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ConfigProviders(ctx context.Context, params *ConfigProvidersParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewConfigProvidersRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) EventSubscribe(ctx context.Context, params *EventSubscribeParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewEventSubscribeRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ExperimentalResourceList(ctx context.Context, params *ExperimentalResourceListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewExperimentalResourceListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ToolList(ctx context.Context, params *ToolListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewToolListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ToolIds(ctx context.Context, params *ToolIdsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewToolIdsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) WorktreeList(ctx context.Context, params *WorktreeListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewWorktreeListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) WorktreeCreateWithBody(ctx context.Context, params *WorktreeCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewWorktreeCreateRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) WorktreeCreate(ctx context.Context, params *WorktreeCreateParams, body WorktreeCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewWorktreeCreateRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FileList(ctx context.Context, params *FileListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFileListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FileRead(ctx context.Context, params *FileReadParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFileReadRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FileStatus(ctx context.Context, params *FileStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFileStatusRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindText(ctx context.Context, params *FindTextParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindTextRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindFiles(ctx context.Context, params *FindFilesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindFilesRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FindSymbols(ctx context.Context, params *FindSymbolsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFindSymbolsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) FormatterStatus(ctx context.Context, params *FormatterStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewFormatterStatusRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GlobalDispose(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGlobalDisposeRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GlobalEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGlobalEventRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GlobalHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGlobalHealthRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) InstanceDispose(ctx context.Context, params *InstanceDisposeParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewInstanceDisposeRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AppLogWithBody(ctx context.Context, params *AppLogParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAppLogRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) AppLog(ctx context.Context, params *AppLogParams, body AppLogJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewAppLogRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) LspStatus(ctx context.Context, params *LspStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewLspStatusRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpStatus(ctx context.Context, params *McpStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpStatusRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAddWithBody(ctx context.Context, params *McpAddParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAddRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAdd(ctx context.Context, params *McpAddParams, body McpAddJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAddRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAuthRemove(ctx context.Context, name string, params *McpAuthRemoveParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAuthRemoveRequest(c.Server, name, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAuthStart(ctx context.Context, name string, params *McpAuthStartParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAuthStartRequest(c.Server, name, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAuthAuthenticate(ctx context.Context, name string, params *McpAuthAuthenticateParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAuthAuthenticateRequest(c.Server, name, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAuthCallbackWithBody(ctx context.Context, name string, params *McpAuthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAuthCallbackRequestWithBody(c.Server, name, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpAuthCallback(ctx context.Context, name string, params *McpAuthCallbackParams, body McpAuthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpAuthCallbackRequest(c.Server, name, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpConnect(ctx context.Context, name string, params *McpConnectParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpConnectRequest(c.Server, name, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) McpDisconnect(ctx context.Context, name string, params *McpDisconnectParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewMcpDisconnectRequest(c.Server, name, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PathGet(ctx context.Context, params *PathGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPathGetRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PermissionList(ctx context.Context, params *PermissionListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPermissionListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PermissionReplyWithBody(ctx context.Context, requestID string, params *PermissionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPermissionReplyRequestWithBody(c.Server, requestID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PermissionReply(ctx context.Context, requestID string, params *PermissionReplyParams, body PermissionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPermissionReplyRequest(c.Server, requestID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProjectList(ctx context.Context, params *ProjectListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProjectListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProjectCurrent(ctx context.Context, params *ProjectCurrentParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProjectCurrentRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProjectUpdateWithBody(ctx context.Context, projectID string, params *ProjectUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProjectUpdateRequestWithBody(c.Server, projectID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProjectUpdate(ctx context.Context, projectID string, params *ProjectUpdateParams, body ProjectUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProjectUpdateRequest(c.Server, projectID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProviderList(ctx context.Context, params *ProviderListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProviderListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProviderAuth(ctx context.Context, params *ProviderAuthParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProviderAuthRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProviderOauthAuthorizeWithBody(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProviderOauthAuthorizeRequestWithBody(c.Server, providerID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProviderOauthAuthorize(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, body ProviderOauthAuthorizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProviderOauthAuthorizeRequest(c.Server, providerID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProviderOauthCallbackWithBody(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProviderOauthCallbackRequestWithBody(c.Server, providerID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) ProviderOauthCallback(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, body ProviderOauthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewProviderOauthCallbackRequest(c.Server, providerID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyList(ctx context.Context, params *PtyListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyCreateWithBody(ctx context.Context, params *PtyCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyCreateRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyCreate(ctx context.Context, params *PtyCreateParams, body PtyCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyCreateRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyRemove(ctx context.Context, ptyID string, params *PtyRemoveParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyRemoveRequest(c.Server, ptyID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyGet(ctx context.Context, ptyID string, params *PtyGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyGetRequest(c.Server, ptyID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyUpdateWithBody(ctx context.Context, ptyID string, params *PtyUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyUpdateRequestWithBody(c.Server, ptyID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyUpdate(ctx context.Context, ptyID string, params *PtyUpdateParams, body PtyUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyUpdateRequest(c.Server, ptyID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PtyConnect(ctx context.Context, ptyID string, params *PtyConnectParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPtyConnectRequest(c.Server, ptyID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) QuestionList(ctx context.Context, params *QuestionListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewQuestionListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) QuestionReject(ctx context.Context, requestID string, params *QuestionRejectParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewQuestionRejectRequest(c.Server, requestID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) QuestionReplyWithBody(ctx context.Context, requestID string, params *QuestionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewQuestionReplyRequestWithBody(c.Server, requestID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) QuestionReply(ctx context.Context, requestID string, params *QuestionReplyParams, body QuestionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewQuestionReplyRequest(c.Server, requestID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionList(ctx context.Context, params *SessionListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionCreateWithBody(ctx context.Context, params *SessionCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionCreateRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionCreate(ctx context.Context, params *SessionCreateParams, body SessionCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionCreateRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionStatus(ctx context.Context, params *SessionStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionStatusRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionDelete(ctx context.Context, sessionID string, params *SessionDeleteParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionDeleteRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionGet(ctx context.Context, sessionID string, params *SessionGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionGetRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionUpdateWithBody(ctx context.Context, sessionID string, params *SessionUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionUpdateRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionUpdate(ctx context.Context, sessionID string, params *SessionUpdateParams, body SessionUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionUpdateRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionAbort(ctx context.Context, sessionID string, params *SessionAbortParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionAbortRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionChildren(ctx context.Context, sessionID string, params *SessionChildrenParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionChildrenRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionCommandWithBody(ctx context.Context, sessionID string, params *SessionCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionCommandRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionCommand(ctx context.Context, sessionID string, params *SessionCommandParams, body SessionCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionCommandRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionDiff(ctx context.Context, sessionID string, params *SessionDiffParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionDiffRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionForkWithBody(ctx context.Context, sessionID string, params *SessionForkParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionForkRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionFork(ctx context.Context, sessionID string, params *SessionForkParams, body SessionForkJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionForkRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionInitWithBody(ctx context.Context, sessionID string, params *SessionInitParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionInitRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionInit(ctx context.Context, sessionID string, params *SessionInitParams, body SessionInitJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionInitRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionMessages(ctx context.Context, sessionID string, params *SessionMessagesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionMessagesRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionPromptWithBody(ctx context.Context, sessionID string, params *SessionPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionPromptRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionPrompt(ctx context.Context, sessionID string, params *SessionPromptParams, body SessionPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionPromptRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionMessage(ctx context.Context, sessionID string, messageID string, params *SessionMessageParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionMessageRequest(c.Server, sessionID, messageID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PartDelete(ctx context.Context, sessionID string, messageID string, partID string, params *PartDeleteParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPartDeleteRequest(c.Server, sessionID, messageID, partID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PartUpdateWithBody(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPartUpdateRequestWithBody(c.Server, sessionID, messageID, partID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PartUpdate(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, body PartUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPartUpdateRequest(c.Server, sessionID, messageID, partID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PermissionRespondWithBody(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPermissionRespondRequestWithBody(c.Server, sessionID, permissionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) PermissionRespond(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, body PermissionRespondJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPermissionRespondRequest(c.Server, sessionID, permissionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionPromptAsyncWithBody(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionPromptAsyncRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionPromptAsync(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, body SessionPromptAsyncJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionPromptAsyncRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionRevertWithBody(ctx context.Context, sessionID string, params *SessionRevertParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionRevertRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionRevert(ctx context.Context, sessionID string, params *SessionRevertParams, body SessionRevertJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionRevertRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionUnshare(ctx context.Context, sessionID string, params *SessionUnshareParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionUnshareRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionShare(ctx context.Context, sessionID string, params *SessionShareParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionShareRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionShellWithBody(ctx context.Context, sessionID string, params *SessionShellParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionShellRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionShell(ctx context.Context, sessionID string, params *SessionShellParams, body SessionShellJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionShellRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionSummarizeWithBody(ctx context.Context, sessionID string, params *SessionSummarizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionSummarizeRequestWithBody(c.Server, sessionID, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionSummarize(ctx context.Context, sessionID string, params *SessionSummarizeParams, body SessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionSummarizeRequest(c.Server, sessionID, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionTodo(ctx context.Context, sessionID string, params *SessionTodoParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionTodoRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) SessionUnrevert(ctx context.Context, sessionID string, params *SessionUnrevertParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewSessionUnrevertRequest(c.Server, sessionID, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiAppendPromptWithBody(ctx context.Context, params *TuiAppendPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiAppendPromptRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiAppendPrompt(ctx context.Context, params *TuiAppendPromptParams, body TuiAppendPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiAppendPromptRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiClearPrompt(ctx context.Context, params *TuiClearPromptParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiClearPromptRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiControlNext(ctx context.Context, params *TuiControlNextParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiControlNextRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiControlResponseWithBody(ctx context.Context, params *TuiControlResponseParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiControlResponseRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiControlResponse(ctx context.Context, params *TuiControlResponseParams, body TuiControlResponseJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiControlResponseRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiExecuteCommandWithBody(ctx context.Context, params *TuiExecuteCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiExecuteCommandRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiExecuteCommand(ctx context.Context, params *TuiExecuteCommandParams, body TuiExecuteCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiExecuteCommandRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiOpenHelp(ctx context.Context, params *TuiOpenHelpParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiOpenHelpRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiOpenModels(ctx context.Context, params *TuiOpenModelsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiOpenModelsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiOpenSessions(ctx context.Context, params *TuiOpenSessionsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiOpenSessionsRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiOpenThemes(ctx context.Context, params *TuiOpenThemesParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiOpenThemesRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiPublishWithBody(ctx context.Context, params *TuiPublishParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiPublishRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiPublish(ctx context.Context, params *TuiPublishParams, body TuiPublishJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiPublishRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiSelectSessionWithBody(ctx context.Context, params *TuiSelectSessionParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiSelectSessionRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiSelectSession(ctx context.Context, params *TuiSelectSessionParams, body TuiSelectSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiSelectSessionRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiShowToastWithBody(ctx context.Context, params *TuiShowToastParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiShowToastRequestWithBody(c.Server, params, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiShowToast(ctx context.Context, params *TuiShowToastParams, body TuiShowToastJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiShowToastRequest(c.Server, params, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) TuiSubmitPrompt(ctx context.Context, params *TuiSubmitPromptParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewTuiSubmitPromptRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) VcsGet(ctx context.Context, params *VcsGetParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewVcsGetRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

// NewAppAgentsRequest generates requests for AppAgents
func NewAppAgentsRequest(server string, params *AppAgentsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/agent")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAuthSetRequest calls the generic AuthSet builder with application/json body
func NewAuthSetRequest(server string, providerID string, params *AuthSetParams, body AuthSetJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAuthSetRequestWithBody(server, providerID, params, "application/json", bodyReader)
}

// NewAuthSetRequestWithBody generates requests for AuthSet with any type of body
func NewAuthSetRequestWithBody(server string, providerID string, params *AuthSetParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "providerID", runtime.ParamLocationPath, providerID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/auth/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewCommandListRequest generates requests for CommandList
func NewCommandListRequest(server string, params *CommandListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/command")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewConfigGetRequest generates requests for ConfigGet
func NewConfigGetRequest(server string, params *ConfigGetParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/config")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewConfigUpdateRequest calls the generic ConfigUpdate builder with application/json body
func NewConfigUpdateRequest(server string, params *ConfigUpdateParams, body ConfigUpdateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewConfigUpdateRequestWithBody(server, params, "application/json", bodyReader)
}

// NewConfigUpdateRequestWithBody generates requests for ConfigUpdate with any type of body
func NewConfigUpdateRequestWithBody(server string, params *ConfigUpdateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/config")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewConfigProvidersRequest generates requests for ConfigProviders
func NewConfigProvidersRequest(server string, params *ConfigProvidersParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/config/providers")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewEventSubscribeRequest generates requests for EventSubscribe
func NewEventSubscribeRequest(server string, params *EventSubscribeParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/event")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewExperimentalResourceListRequest generates requests for ExperimentalResourceList
func NewExperimentalResourceListRequest(server string, params *ExperimentalResourceListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/experimental/resource")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewToolListRequest generates requests for ToolList
func NewToolListRequest(server string, params *ToolListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/experimental/tool")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "provider", runtime.ParamLocationQuery, params.Provider); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "model", runtime.ParamLocationQuery, params.Model); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewToolIdsRequest generates requests for ToolIds
func NewToolIdsRequest(server string, params *ToolIdsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/experimental/tool/ids")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewWorktreeListRequest generates requests for WorktreeList
func NewWorktreeListRequest(server string, params *WorktreeListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/experimental/worktree")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewWorktreeCreateRequest calls the generic WorktreeCreate builder with application/json body
func NewWorktreeCreateRequest(server string, params *WorktreeCreateParams, body WorktreeCreateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewWorktreeCreateRequestWithBody(server, params, "application/json", bodyReader)
}

// NewWorktreeCreateRequestWithBody generates requests for WorktreeCreate with any type of body
func NewWorktreeCreateRequestWithBody(server string, params *WorktreeCreateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/experimental/worktree")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewFileListRequest generates requests for FileList
func NewFileListRequest(server string, params *FileListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/file")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "path", runtime.ParamLocationQuery, params.Path); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFileReadRequest generates requests for FileRead
func NewFileReadRequest(server string, params *FileReadParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/file/content")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "path", runtime.ParamLocationQuery, params.Path); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFileStatusRequest generates requests for FileStatus
func NewFileStatusRequest(server string, params *FileStatusParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/file/status")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindTextRequest generates requests for FindText
func NewFindTextRequest(server string, params *FindTextParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/find")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "pattern", runtime.ParamLocationQuery, params.Pattern); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindFilesRequest generates requests for FindFiles
func NewFindFilesRequest(server string, params *FindFilesParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/find/file")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "query", runtime.ParamLocationQuery, params.Query); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		if params.Dirs != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "dirs", runtime.ParamLocationQuery, *params.Dirs); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Type != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "type", runtime.ParamLocationQuery, *params.Type); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Limit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFindSymbolsRequest generates requests for FindSymbols
func NewFindSymbolsRequest(server string, params *FindSymbolsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/find/symbol")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "query", runtime.ParamLocationQuery, params.Query); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewFormatterStatusRequest generates requests for FormatterStatus
func NewFormatterStatusRequest(server string, params *FormatterStatusParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/formatter")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGlobalDisposeRequest generates requests for GlobalDispose
func NewGlobalDisposeRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/global/dispose")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGlobalEventRequest generates requests for GlobalEvent
func NewGlobalEventRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/global/event")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGlobalHealthRequest generates requests for GlobalHealth
func NewGlobalHealthRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/global/health")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewInstanceDisposeRequest generates requests for InstanceDispose
func NewInstanceDisposeRequest(server string, params *InstanceDisposeParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/instance/dispose")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewAppLogRequest calls the generic AppLog builder with application/json body
func NewAppLogRequest(server string, params *AppLogParams, body AppLogJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewAppLogRequestWithBody(server, params, "application/json", bodyReader)
}

// NewAppLogRequestWithBody generates requests for AppLog with any type of body
func NewAppLogRequestWithBody(server string, params *AppLogParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/log")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewLspStatusRequest generates requests for LspStatus
func NewLspStatusRequest(server string, params *LspStatusParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/lsp")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMcpStatusRequest generates requests for McpStatus
func NewMcpStatusRequest(server string, params *McpStatusParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMcpAddRequest calls the generic McpAdd builder with application/json body
func NewMcpAddRequest(server string, params *McpAddParams, body McpAddJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewMcpAddRequestWithBody(server, params, "application/json", bodyReader)
}

// NewMcpAddRequestWithBody generates requests for McpAdd with any type of body
func NewMcpAddRequestWithBody(server string, params *McpAddParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewMcpAuthRemoveRequest generates requests for McpAuthRemove
func NewMcpAuthRemoveRequest(server string, name string, params *McpAuthRemoveParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp/%s/auth", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMcpAuthStartRequest generates requests for McpAuthStart
func NewMcpAuthStartRequest(server string, name string, params *McpAuthStartParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp/%s/auth", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMcpAuthAuthenticateRequest generates requests for McpAuthAuthenticate
func NewMcpAuthAuthenticateRequest(server string, name string, params *McpAuthAuthenticateParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp/%s/auth/authenticate", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMcpAuthCallbackRequest calls the generic McpAuthCallback builder with application/json body
func NewMcpAuthCallbackRequest(server string, name string, params *McpAuthCallbackParams, body McpAuthCallbackJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewMcpAuthCallbackRequestWithBody(server, name, params, "application/json", bodyReader)
}

// NewMcpAuthCallbackRequestWithBody generates requests for McpAuthCallback with any type of body
func NewMcpAuthCallbackRequestWithBody(server string, name string, params *McpAuthCallbackParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp/%s/auth/callback", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewMcpConnectRequest generates requests for McpConnect
func NewMcpConnectRequest(server string, name string, params *McpConnectParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp/%s/connect", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewMcpDisconnectRequest generates requests for McpDisconnect
func NewMcpDisconnectRequest(server string, name string, params *McpDisconnectParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "name", runtime.ParamLocationPath, name)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/mcp/%s/disconnect", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPathGetRequest generates requests for PathGet
func NewPathGetRequest(server string, params *PathGetParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/path")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPermissionListRequest generates requests for PermissionList
func NewPermissionListRequest(server string, params *PermissionListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/permission")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPermissionReplyRequest calls the generic PermissionReply builder with application/json body
func NewPermissionReplyRequest(server string, requestID string, params *PermissionReplyParams, body PermissionReplyJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPermissionReplyRequestWithBody(server, requestID, params, "application/json", bodyReader)
}

// NewPermissionReplyRequestWithBody generates requests for PermissionReply with any type of body
func NewPermissionReplyRequestWithBody(server string, requestID string, params *PermissionReplyParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "requestID", runtime.ParamLocationPath, requestID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/permission/%s/reply", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewProjectListRequest generates requests for ProjectList
func NewProjectListRequest(server string, params *ProjectListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/project")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewProjectCurrentRequest generates requests for ProjectCurrent
func NewProjectCurrentRequest(server string, params *ProjectCurrentParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/project/current")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewProjectUpdateRequest calls the generic ProjectUpdate builder with application/json body
func NewProjectUpdateRequest(server string, projectID string, params *ProjectUpdateParams, body ProjectUpdateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewProjectUpdateRequestWithBody(server, projectID, params, "application/json", bodyReader)
}

// NewProjectUpdateRequestWithBody generates requests for ProjectUpdate with any type of body
func NewProjectUpdateRequestWithBody(server string, projectID string, params *ProjectUpdateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "projectID", runtime.ParamLocationPath, projectID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/project/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewProviderListRequest generates requests for ProviderList
func NewProviderListRequest(server string, params *ProviderListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/provider")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewProviderAuthRequest generates requests for ProviderAuth
func NewProviderAuthRequest(server string, params *ProviderAuthParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/provider/auth")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewProviderOauthAuthorizeRequest calls the generic ProviderOauthAuthorize builder with application/json body
func NewProviderOauthAuthorizeRequest(server string, providerID string, params *ProviderOauthAuthorizeParams, body ProviderOauthAuthorizeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewProviderOauthAuthorizeRequestWithBody(server, providerID, params, "application/json", bodyReader)
}

// NewProviderOauthAuthorizeRequestWithBody generates requests for ProviderOauthAuthorize with any type of body
func NewProviderOauthAuthorizeRequestWithBody(server string, providerID string, params *ProviderOauthAuthorizeParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "providerID", runtime.ParamLocationPath, providerID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/provider/%s/oauth/authorize", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewProviderOauthCallbackRequest calls the generic ProviderOauthCallback builder with application/json body
func NewProviderOauthCallbackRequest(server string, providerID string, params *ProviderOauthCallbackParams, body ProviderOauthCallbackJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewProviderOauthCallbackRequestWithBody(server, providerID, params, "application/json", bodyReader)
}

// NewProviderOauthCallbackRequestWithBody generates requests for ProviderOauthCallback with any type of body
func NewProviderOauthCallbackRequestWithBody(server string, providerID string, params *ProviderOauthCallbackParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "providerID", runtime.ParamLocationPath, providerID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/provider/%s/oauth/callback", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewPtyListRequest generates requests for PtyList
func NewPtyListRequest(server string, params *PtyListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/pty")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPtyCreateRequest calls the generic PtyCreate builder with application/json body
func NewPtyCreateRequest(server string, params *PtyCreateParams, body PtyCreateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPtyCreateRequestWithBody(server, params, "application/json", bodyReader)
}

// NewPtyCreateRequestWithBody generates requests for PtyCreate with any type of body
func NewPtyCreateRequestWithBody(server string, params *PtyCreateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/pty")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewPtyRemoveRequest generates requests for PtyRemove
func NewPtyRemoveRequest(server string, ptyID string, params *PtyRemoveParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "ptyID", runtime.ParamLocationPath, ptyID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/pty/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPtyGetRequest generates requests for PtyGet
func NewPtyGetRequest(server string, ptyID string, params *PtyGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "ptyID", runtime.ParamLocationPath, ptyID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/pty/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPtyUpdateRequest calls the generic PtyUpdate builder with application/json body
func NewPtyUpdateRequest(server string, ptyID string, params *PtyUpdateParams, body PtyUpdateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPtyUpdateRequestWithBody(server, ptyID, params, "application/json", bodyReader)
}

// NewPtyUpdateRequestWithBody generates requests for PtyUpdate with any type of body
func NewPtyUpdateRequestWithBody(server string, ptyID string, params *PtyUpdateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "ptyID", runtime.ParamLocationPath, ptyID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/pty/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewPtyConnectRequest generates requests for PtyConnect
func NewPtyConnectRequest(server string, ptyID string, params *PtyConnectParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "ptyID", runtime.ParamLocationPath, ptyID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/pty/%s/connect", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewQuestionListRequest generates requests for QuestionList
func NewQuestionListRequest(server string, params *QuestionListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/question")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewQuestionRejectRequest generates requests for QuestionReject
func NewQuestionRejectRequest(server string, requestID string, params *QuestionRejectParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "requestID", runtime.ParamLocationPath, requestID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/question/%s/reject", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewQuestionReplyRequest calls the generic QuestionReply builder with application/json body
func NewQuestionReplyRequest(server string, requestID string, params *QuestionReplyParams, body QuestionReplyJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewQuestionReplyRequestWithBody(server, requestID, params, "application/json", bodyReader)
}

// NewQuestionReplyRequestWithBody generates requests for QuestionReply with any type of body
func NewQuestionReplyRequestWithBody(server string, requestID string, params *QuestionReplyParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "requestID", runtime.ParamLocationPath, requestID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/question/%s/reply", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionListRequest generates requests for SessionList
func NewSessionListRequest(server string, params *SessionListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Roots != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "roots", runtime.ParamLocationQuery, *params.Roots); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Start != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "start", runtime.ParamLocationQuery, *params.Start); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Search != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "search", runtime.ParamLocationQuery, *params.Search); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Limit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionCreateRequest calls the generic SessionCreate builder with application/json body
func NewSessionCreateRequest(server string, params *SessionCreateParams, body SessionCreateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionCreateRequestWithBody(server, params, "application/json", bodyReader)
}

// NewSessionCreateRequestWithBody generates requests for SessionCreate with any type of body
func NewSessionCreateRequestWithBody(server string, params *SessionCreateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionStatusRequest generates requests for SessionStatus
func NewSessionStatusRequest(server string, params *SessionStatusParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/status")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionDeleteRequest generates requests for SessionDelete
func NewSessionDeleteRequest(server string, sessionID string, params *SessionDeleteParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionGetRequest generates requests for SessionGet
func NewSessionGetRequest(server string, sessionID string, params *SessionGetParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionUpdateRequest calls the generic SessionUpdate builder with application/json body
func NewSessionUpdateRequest(server string, sessionID string, params *SessionUpdateParams, body SessionUpdateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionUpdateRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionUpdateRequestWithBody generates requests for SessionUpdate with any type of body
func NewSessionUpdateRequestWithBody(server string, sessionID string, params *SessionUpdateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionAbortRequest generates requests for SessionAbort
func NewSessionAbortRequest(server string, sessionID string, params *SessionAbortParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/abort", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionChildrenRequest generates requests for SessionChildren
func NewSessionChildrenRequest(server string, sessionID string, params *SessionChildrenParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/children", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionCommandRequest calls the generic SessionCommand builder with application/json body
func NewSessionCommandRequest(server string, sessionID string, params *SessionCommandParams, body SessionCommandJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionCommandRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionCommandRequestWithBody generates requests for SessionCommand with any type of body
func NewSessionCommandRequestWithBody(server string, sessionID string, params *SessionCommandParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/command", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionDiffRequest generates requests for SessionDiff
func NewSessionDiffRequest(server string, sessionID string, params *SessionDiffParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/diff", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.MessageID != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "messageID", runtime.ParamLocationQuery, *params.MessageID); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionForkRequest calls the generic SessionFork builder with application/json body
func NewSessionForkRequest(server string, sessionID string, params *SessionForkParams, body SessionForkJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionForkRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionForkRequestWithBody generates requests for SessionFork with any type of body
func NewSessionForkRequestWithBody(server string, sessionID string, params *SessionForkParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/fork", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionInitRequest calls the generic SessionInit builder with application/json body
func NewSessionInitRequest(server string, sessionID string, params *SessionInitParams, body SessionInitJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionInitRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionInitRequestWithBody generates requests for SessionInit with any type of body
func NewSessionInitRequestWithBody(server string, sessionID string, params *SessionInitParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/init", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionMessagesRequest generates requests for SessionMessages
func NewSessionMessagesRequest(server string, sessionID string, params *SessionMessagesParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/message", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		if params.Limit != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "limit", runtime.ParamLocationQuery, *params.Limit); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionPromptRequest calls the generic SessionPrompt builder with application/json body
func NewSessionPromptRequest(server string, sessionID string, params *SessionPromptParams, body SessionPromptJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionPromptRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionPromptRequestWithBody generates requests for SessionPrompt with any type of body
func NewSessionPromptRequestWithBody(server string, sessionID string, params *SessionPromptParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/message", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionMessageRequest generates requests for SessionMessage
func NewSessionMessageRequest(server string, sessionID string, messageID string, params *SessionMessageParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "messageID", runtime.ParamLocationPath, messageID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/message/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPartDeleteRequest generates requests for PartDelete
func NewPartDeleteRequest(server string, sessionID string, messageID string, partID string, params *PartDeleteParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "messageID", runtime.ParamLocationPath, messageID)
	if err != nil {
		return nil, err
	}

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "partID", runtime.ParamLocationPath, partID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/message/%s/part/%s", pathParam0, pathParam1, pathParam2)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewPartUpdateRequest calls the generic PartUpdate builder with application/json body
func NewPartUpdateRequest(server string, sessionID string, messageID string, partID string, params *PartUpdateParams, body PartUpdateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPartUpdateRequestWithBody(server, sessionID, messageID, partID, params, "application/json", bodyReader)
}

// NewPartUpdateRequestWithBody generates requests for PartUpdate with any type of body
func NewPartUpdateRequestWithBody(server string, sessionID string, messageID string, partID string, params *PartUpdateParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "messageID", runtime.ParamLocationPath, messageID)
	if err != nil {
		return nil, err
	}

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "partID", runtime.ParamLocationPath, partID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/message/%s/part/%s", pathParam0, pathParam1, pathParam2)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("PATCH", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewPermissionRespondRequest calls the generic PermissionRespond builder with application/json body
func NewPermissionRespondRequest(server string, sessionID string, permissionID string, params *PermissionRespondParams, body PermissionRespondJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPermissionRespondRequestWithBody(server, sessionID, permissionID, params, "application/json", bodyReader)
}

// NewPermissionRespondRequestWithBody generates requests for PermissionRespond with any type of body
func NewPermissionRespondRequestWithBody(server string, sessionID string, permissionID string, params *PermissionRespondParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "permissionID", runtime.ParamLocationPath, permissionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/permissions/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionPromptAsyncRequest calls the generic SessionPromptAsync builder with application/json body
func NewSessionPromptAsyncRequest(server string, sessionID string, params *SessionPromptAsyncParams, body SessionPromptAsyncJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionPromptAsyncRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionPromptAsyncRequestWithBody generates requests for SessionPromptAsync with any type of body
func NewSessionPromptAsyncRequestWithBody(server string, sessionID string, params *SessionPromptAsyncParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/prompt_async", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionRevertRequest calls the generic SessionRevert builder with application/json body
func NewSessionRevertRequest(server string, sessionID string, params *SessionRevertParams, body SessionRevertJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionRevertRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionRevertRequestWithBody generates requests for SessionRevert with any type of body
func NewSessionRevertRequestWithBody(server string, sessionID string, params *SessionRevertParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/revert", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionUnshareRequest generates requests for SessionUnshare
func NewSessionUnshareRequest(server string, sessionID string, params *SessionUnshareParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/share", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionShareRequest generates requests for SessionShare
func NewSessionShareRequest(server string, sessionID string, params *SessionShareParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/share", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionShellRequest calls the generic SessionShell builder with application/json body
func NewSessionShellRequest(server string, sessionID string, params *SessionShellParams, body SessionShellJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionShellRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionShellRequestWithBody generates requests for SessionShell with any type of body
func NewSessionShellRequestWithBody(server string, sessionID string, params *SessionShellParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/shell", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionSummarizeRequest calls the generic SessionSummarize builder with application/json body
func NewSessionSummarizeRequest(server string, sessionID string, params *SessionSummarizeParams, body SessionSummarizeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewSessionSummarizeRequestWithBody(server, sessionID, params, "application/json", bodyReader)
}

// NewSessionSummarizeRequestWithBody generates requests for SessionSummarize with any type of body
func NewSessionSummarizeRequestWithBody(server string, sessionID string, params *SessionSummarizeParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/summarize", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewSessionTodoRequest generates requests for SessionTodo
func NewSessionTodoRequest(server string, sessionID string, params *SessionTodoParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/todo", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewSessionUnrevertRequest generates requests for SessionUnrevert
func NewSessionUnrevertRequest(server string, sessionID string, params *SessionUnrevertParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "sessionID", runtime.ParamLocationPath, sessionID)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/session/%s/unrevert", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiAppendPromptRequest calls the generic TuiAppendPrompt builder with application/json body
func NewTuiAppendPromptRequest(server string, params *TuiAppendPromptParams, body TuiAppendPromptJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewTuiAppendPromptRequestWithBody(server, params, "application/json", bodyReader)
}

// NewTuiAppendPromptRequestWithBody generates requests for TuiAppendPrompt with any type of body
func NewTuiAppendPromptRequestWithBody(server string, params *TuiAppendPromptParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/append-prompt")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewTuiClearPromptRequest generates requests for TuiClearPrompt
func NewTuiClearPromptRequest(server string, params *TuiClearPromptParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/clear-prompt")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiControlNextRequest generates requests for TuiControlNext
func NewTuiControlNextRequest(server string, params *TuiControlNextParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/control/next")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiControlResponseRequest calls the generic TuiControlResponse builder with application/json body
func NewTuiControlResponseRequest(server string, params *TuiControlResponseParams, body TuiControlResponseJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewTuiControlResponseRequestWithBody(server, params, "application/json", bodyReader)
}

// NewTuiControlResponseRequestWithBody generates requests for TuiControlResponse with any type of body
func NewTuiControlResponseRequestWithBody(server string, params *TuiControlResponseParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/control/response")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewTuiExecuteCommandRequest calls the generic TuiExecuteCommand builder with application/json body
func NewTuiExecuteCommandRequest(server string, params *TuiExecuteCommandParams, body TuiExecuteCommandJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewTuiExecuteCommandRequestWithBody(server, params, "application/json", bodyReader)
}

// NewTuiExecuteCommandRequestWithBody generates requests for TuiExecuteCommand with any type of body
func NewTuiExecuteCommandRequestWithBody(server string, params *TuiExecuteCommandParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/execute-command")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewTuiOpenHelpRequest generates requests for TuiOpenHelp
func NewTuiOpenHelpRequest(server string, params *TuiOpenHelpParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/open-help")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiOpenModelsRequest generates requests for TuiOpenModels
func NewTuiOpenModelsRequest(server string, params *TuiOpenModelsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/open-models")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiOpenSessionsRequest generates requests for TuiOpenSessions
func NewTuiOpenSessionsRequest(server string, params *TuiOpenSessionsParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/open-sessions")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiOpenThemesRequest generates requests for TuiOpenThemes
func NewTuiOpenThemesRequest(server string, params *TuiOpenThemesParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/open-themes")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewTuiPublishRequest calls the generic TuiPublish builder with application/json body
func NewTuiPublishRequest(server string, params *TuiPublishParams, body TuiPublishJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewTuiPublishRequestWithBody(server, params, "application/json", bodyReader)
}

// NewTuiPublishRequestWithBody generates requests for TuiPublish with any type of body
func NewTuiPublishRequestWithBody(server string, params *TuiPublishParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/publish")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewTuiSelectSessionRequest calls the generic TuiSelectSession builder with application/json body
func NewTuiSelectSessionRequest(server string, params *TuiSelectSessionParams, body TuiSelectSessionJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewTuiSelectSessionRequestWithBody(server, params, "application/json", bodyReader)
}

// NewTuiSelectSessionRequestWithBody generates requests for TuiSelectSession with any type of body
func NewTuiSelectSessionRequestWithBody(server string, params *TuiSelectSessionParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/select-session")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewTuiShowToastRequest calls the generic TuiShowToast builder with application/json body
func NewTuiShowToastRequest(server string, params *TuiShowToastParams, body TuiShowToastJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewTuiShowToastRequestWithBody(server, params, "application/json", bodyReader)
}

// NewTuiShowToastRequestWithBody generates requests for TuiShowToast with any type of body
func NewTuiShowToastRequestWithBody(server string, params *TuiShowToastParams, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/show-toast")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewTuiSubmitPromptRequest generates requests for TuiSubmitPrompt
func NewTuiSubmitPromptRequest(server string, params *TuiSubmitPromptParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/tui/submit-prompt")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewVcsGetRequest generates requests for VcsGet
func NewVcsGetRequest(server string, params *VcsGetParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/vcs")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	if params != nil {
		queryValues := queryURL.Query()

		if params.Directory != nil {

			if queryFrag, err := runtime.StyleParamWithLocation("form", true, "directory", runtime.ParamLocationQuery, *params.Directory); err != nil {
				return nil, err
			} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
				return nil, err
			} else {
				for k, v := range parsed {
					for _, v2 := range v {
						queryValues.Add(k, v2)
					}
				}
			}

		}

		queryURL.RawQuery = queryValues.Encode()
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
	for _, r := range c.RequestEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	for _, r := range additionalEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	return nil
}

// ClientWithResponses builds on ClientInterface to offer response payloads
type ClientWithResponses struct {
	ClientInterface
}

// NewClientWithResponses creates a new ClientWithResponses, which wraps
// Client with return type handling
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
	client, err := NewClient(server, opts...)
	if err != nil {
		return nil, err
	}
	return &ClientWithResponses{client}, nil
}

// WithBaseURL overrides the baseURL.
func WithBaseURL(baseURL string) ClientOption {
	return func(c *Client) error {
		newBaseURL, err := url.Parse(baseURL)
		if err != nil {
			return err
		}
		c.Server = newBaseURL.String()
		return nil
	}
}

// ClientWithResponsesInterface is the interface specification for the client with responses above.
type ClientWithResponsesInterface interface {
	// AppAgentsWithResponse request
	AppAgentsWithResponse(ctx context.Context, params *AppAgentsParams, reqEditors ...RequestEditorFn) (*AppAgentsResponse, error)

	// AuthSetWithBodyWithResponse request with any body
	AuthSetWithBodyWithResponse(ctx context.Context, providerID string, params *AuthSetParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AuthSetResponse, error)

	AuthSetWithResponse(ctx context.Context, providerID string, params *AuthSetParams, body AuthSetJSONRequestBody, reqEditors ...RequestEditorFn) (*AuthSetResponse, error)

	// CommandListWithResponse request
	CommandListWithResponse(ctx context.Context, params *CommandListParams, reqEditors ...RequestEditorFn) (*CommandListResponse, error)

	// ConfigGetWithResponse request
	ConfigGetWithResponse(ctx context.Context, params *ConfigGetParams, reqEditors ...RequestEditorFn) (*ConfigGetResponse, error)

	// ConfigUpdateWithBodyWithResponse request with any body
	ConfigUpdateWithBodyWithResponse(ctx context.Context, params *ConfigUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ConfigUpdateResponse, error)

	ConfigUpdateWithResponse(ctx context.Context, params *ConfigUpdateParams, body ConfigUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*ConfigUpdateResponse, error)

	// ConfigProvidersWithResponse request
	ConfigProvidersWithResponse(ctx context.Context, params *ConfigProvidersParams, reqEditors ...RequestEditorFn) (*ConfigProvidersResponse, error)

	// EventSubscribeWithResponse request
	EventSubscribeWithResponse(ctx context.Context, params *EventSubscribeParams, reqEditors ...RequestEditorFn) (*EventSubscribeResponse, error)

	// ExperimentalResourceListWithResponse request
	ExperimentalResourceListWithResponse(ctx context.Context, params *ExperimentalResourceListParams, reqEditors ...RequestEditorFn) (*ExperimentalResourceListResponse, error)

	// ToolListWithResponse request
	ToolListWithResponse(ctx context.Context, params *ToolListParams, reqEditors ...RequestEditorFn) (*ToolListResponse, error)

	// ToolIdsWithResponse request
	ToolIdsWithResponse(ctx context.Context, params *ToolIdsParams, reqEditors ...RequestEditorFn) (*ToolIdsResponse, error)

	// WorktreeListWithResponse request
	WorktreeListWithResponse(ctx context.Context, params *WorktreeListParams, reqEditors ...RequestEditorFn) (*WorktreeListResponse, error)

	// WorktreeCreateWithBodyWithResponse request with any body
	WorktreeCreateWithBodyWithResponse(ctx context.Context, params *WorktreeCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*WorktreeCreateResponse, error)

	WorktreeCreateWithResponse(ctx context.Context, params *WorktreeCreateParams, body WorktreeCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*WorktreeCreateResponse, error)

	// FileListWithResponse request
	FileListWithResponse(ctx context.Context, params *FileListParams, reqEditors ...RequestEditorFn) (*FileListResponse, error)

	// FileReadWithResponse request
	FileReadWithResponse(ctx context.Context, params *FileReadParams, reqEditors ...RequestEditorFn) (*FileReadResponse, error)

	// FileStatusWithResponse request
	FileStatusWithResponse(ctx context.Context, params *FileStatusParams, reqEditors ...RequestEditorFn) (*FileStatusResponse, error)

	// FindTextWithResponse request
	FindTextWithResponse(ctx context.Context, params *FindTextParams, reqEditors ...RequestEditorFn) (*FindTextResponse, error)

	// FindFilesWithResponse request
	FindFilesWithResponse(ctx context.Context, params *FindFilesParams, reqEditors ...RequestEditorFn) (*FindFilesResponse, error)

	// FindSymbolsWithResponse request
	FindSymbolsWithResponse(ctx context.Context, params *FindSymbolsParams, reqEditors ...RequestEditorFn) (*FindSymbolsResponse, error)

	// FormatterStatusWithResponse request
	FormatterStatusWithResponse(ctx context.Context, params *FormatterStatusParams, reqEditors ...RequestEditorFn) (*FormatterStatusResponse, error)

	// GlobalDisposeWithResponse request
	GlobalDisposeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GlobalDisposeResponse, error)

	// GlobalEventWithResponse request
	GlobalEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GlobalEventResponse, error)

	// GlobalHealthWithResponse request
	GlobalHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GlobalHealthResponse, error)

	// InstanceDisposeWithResponse request
	InstanceDisposeWithResponse(ctx context.Context, params *InstanceDisposeParams, reqEditors ...RequestEditorFn) (*InstanceDisposeResponse, error)

	// AppLogWithBodyWithResponse request with any body
	AppLogWithBodyWithResponse(ctx context.Context, params *AppLogParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AppLogResponse, error)

	AppLogWithResponse(ctx context.Context, params *AppLogParams, body AppLogJSONRequestBody, reqEditors ...RequestEditorFn) (*AppLogResponse, error)

	// LspStatusWithResponse request
	LspStatusWithResponse(ctx context.Context, params *LspStatusParams, reqEditors ...RequestEditorFn) (*LspStatusResponse, error)

	// McpStatusWithResponse request
	McpStatusWithResponse(ctx context.Context, params *McpStatusParams, reqEditors ...RequestEditorFn) (*McpStatusResponse, error)

	// McpAddWithBodyWithResponse request with any body
	McpAddWithBodyWithResponse(ctx context.Context, params *McpAddParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*McpAddResponse, error)

	McpAddWithResponse(ctx context.Context, params *McpAddParams, body McpAddJSONRequestBody, reqEditors ...RequestEditorFn) (*McpAddResponse, error)

	// McpAuthRemoveWithResponse request
	McpAuthRemoveWithResponse(ctx context.Context, name string, params *McpAuthRemoveParams, reqEditors ...RequestEditorFn) (*McpAuthRemoveResponse, error)

	// McpAuthStartWithResponse request
	McpAuthStartWithResponse(ctx context.Context, name string, params *McpAuthStartParams, reqEditors ...RequestEditorFn) (*McpAuthStartResponse, error)

	// McpAuthAuthenticateWithResponse request
	McpAuthAuthenticateWithResponse(ctx context.Context, name string, params *McpAuthAuthenticateParams, reqEditors ...RequestEditorFn) (*McpAuthAuthenticateResponse, error)

	// McpAuthCallbackWithBodyWithResponse request with any body
	McpAuthCallbackWithBodyWithResponse(ctx context.Context, name string, params *McpAuthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*McpAuthCallbackResponse, error)

	McpAuthCallbackWithResponse(ctx context.Context, name string, params *McpAuthCallbackParams, body McpAuthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*McpAuthCallbackResponse, error)

	// McpConnectWithResponse request
	McpConnectWithResponse(ctx context.Context, name string, params *McpConnectParams, reqEditors ...RequestEditorFn) (*McpConnectResponse, error)

	// McpDisconnectWithResponse request
	McpDisconnectWithResponse(ctx context.Context, name string, params *McpDisconnectParams, reqEditors ...RequestEditorFn) (*McpDisconnectResponse, error)

	// PathGetWithResponse request
	PathGetWithResponse(ctx context.Context, params *PathGetParams, reqEditors ...RequestEditorFn) (*PathGetResponse, error)

	// PermissionListWithResponse request
	PermissionListWithResponse(ctx context.Context, params *PermissionListParams, reqEditors ...RequestEditorFn) (*PermissionListResponse, error)

	// PermissionReplyWithBodyWithResponse request with any body
	PermissionReplyWithBodyWithResponse(ctx context.Context, requestID string, params *PermissionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PermissionReplyResponse, error)

	PermissionReplyWithResponse(ctx context.Context, requestID string, params *PermissionReplyParams, body PermissionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*PermissionReplyResponse, error)

	// ProjectListWithResponse request
	ProjectListWithResponse(ctx context.Context, params *ProjectListParams, reqEditors ...RequestEditorFn) (*ProjectListResponse, error)

	// ProjectCurrentWithResponse request
	ProjectCurrentWithResponse(ctx context.Context, params *ProjectCurrentParams, reqEditors ...RequestEditorFn) (*ProjectCurrentResponse, error)

	// ProjectUpdateWithBodyWithResponse request with any body
	ProjectUpdateWithBodyWithResponse(ctx context.Context, projectID string, params *ProjectUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProjectUpdateResponse, error)

	ProjectUpdateWithResponse(ctx context.Context, projectID string, params *ProjectUpdateParams, body ProjectUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*ProjectUpdateResponse, error)

	// ProviderListWithResponse request
	ProviderListWithResponse(ctx context.Context, params *ProviderListParams, reqEditors ...RequestEditorFn) (*ProviderListResponse, error)

	// ProviderAuthWithResponse request
	ProviderAuthWithResponse(ctx context.Context, params *ProviderAuthParams, reqEditors ...RequestEditorFn) (*ProviderAuthResponse, error)

	// ProviderOauthAuthorizeWithBodyWithResponse request with any body
	ProviderOauthAuthorizeWithBodyWithResponse(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProviderOauthAuthorizeResponse, error)

	ProviderOauthAuthorizeWithResponse(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, body ProviderOauthAuthorizeJSONRequestBody, reqEditors ...RequestEditorFn) (*ProviderOauthAuthorizeResponse, error)

	// ProviderOauthCallbackWithBodyWithResponse request with any body
	ProviderOauthCallbackWithBodyWithResponse(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProviderOauthCallbackResponse, error)

	ProviderOauthCallbackWithResponse(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, body ProviderOauthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*ProviderOauthCallbackResponse, error)

	// PtyListWithResponse request
	PtyListWithResponse(ctx context.Context, params *PtyListParams, reqEditors ...RequestEditorFn) (*PtyListResponse, error)

	// PtyCreateWithBodyWithResponse request with any body
	PtyCreateWithBodyWithResponse(ctx context.Context, params *PtyCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PtyCreateResponse, error)

	PtyCreateWithResponse(ctx context.Context, params *PtyCreateParams, body PtyCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*PtyCreateResponse, error)

	// PtyRemoveWithResponse request
	PtyRemoveWithResponse(ctx context.Context, ptyID string, params *PtyRemoveParams, reqEditors ...RequestEditorFn) (*PtyRemoveResponse, error)

	// PtyGetWithResponse request
	PtyGetWithResponse(ctx context.Context, ptyID string, params *PtyGetParams, reqEditors ...RequestEditorFn) (*PtyGetResponse, error)

	// PtyUpdateWithBodyWithResponse request with any body
	PtyUpdateWithBodyWithResponse(ctx context.Context, ptyID string, params *PtyUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PtyUpdateResponse, error)

	PtyUpdateWithResponse(ctx context.Context, ptyID string, params *PtyUpdateParams, body PtyUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*PtyUpdateResponse, error)

	// PtyConnectWithResponse request
	PtyConnectWithResponse(ctx context.Context, ptyID string, params *PtyConnectParams, reqEditors ...RequestEditorFn) (*PtyConnectResponse, error)

	// QuestionListWithResponse request
	QuestionListWithResponse(ctx context.Context, params *QuestionListParams, reqEditors ...RequestEditorFn) (*QuestionListResponse, error)

	// QuestionRejectWithResponse request
	QuestionRejectWithResponse(ctx context.Context, requestID string, params *QuestionRejectParams, reqEditors ...RequestEditorFn) (*QuestionRejectResponse, error)

	// QuestionReplyWithBodyWithResponse request with any body
	QuestionReplyWithBodyWithResponse(ctx context.Context, requestID string, params *QuestionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*QuestionReplyResponse, error)

	QuestionReplyWithResponse(ctx context.Context, requestID string, params *QuestionReplyParams, body QuestionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*QuestionReplyResponse, error)

	// SessionListWithResponse request
	SessionListWithResponse(ctx context.Context, params *SessionListParams, reqEditors ...RequestEditorFn) (*SessionListResponse, error)

	// SessionCreateWithBodyWithResponse request with any body
	SessionCreateWithBodyWithResponse(ctx context.Context, params *SessionCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionCreateResponse, error)

	SessionCreateWithResponse(ctx context.Context, params *SessionCreateParams, body SessionCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionCreateResponse, error)

	// SessionStatusWithResponse request
	SessionStatusWithResponse(ctx context.Context, params *SessionStatusParams, reqEditors ...RequestEditorFn) (*SessionStatusResponse, error)

	// SessionDeleteWithResponse request
	SessionDeleteWithResponse(ctx context.Context, sessionID string, params *SessionDeleteParams, reqEditors ...RequestEditorFn) (*SessionDeleteResponse, error)

	// SessionGetWithResponse request
	SessionGetWithResponse(ctx context.Context, sessionID string, params *SessionGetParams, reqEditors ...RequestEditorFn) (*SessionGetResponse, error)

	// SessionUpdateWithBodyWithResponse request with any body
	SessionUpdateWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionUpdateResponse, error)

	SessionUpdateWithResponse(ctx context.Context, sessionID string, params *SessionUpdateParams, body SessionUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionUpdateResponse, error)

	// SessionAbortWithResponse request
	SessionAbortWithResponse(ctx context.Context, sessionID string, params *SessionAbortParams, reqEditors ...RequestEditorFn) (*SessionAbortResponse, error)

	// SessionChildrenWithResponse request
	SessionChildrenWithResponse(ctx context.Context, sessionID string, params *SessionChildrenParams, reqEditors ...RequestEditorFn) (*SessionChildrenResponse, error)

	// SessionCommandWithBodyWithResponse request with any body
	SessionCommandWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionCommandResponse, error)

	SessionCommandWithResponse(ctx context.Context, sessionID string, params *SessionCommandParams, body SessionCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionCommandResponse, error)

	// SessionDiffWithResponse request
	SessionDiffWithResponse(ctx context.Context, sessionID string, params *SessionDiffParams, reqEditors ...RequestEditorFn) (*SessionDiffResponse, error)

	// SessionForkWithBodyWithResponse request with any body
	SessionForkWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionForkParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionForkResponse, error)

	SessionForkWithResponse(ctx context.Context, sessionID string, params *SessionForkParams, body SessionForkJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionForkResponse, error)

	// SessionInitWithBodyWithResponse request with any body
	SessionInitWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionInitParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionInitResponse, error)

	SessionInitWithResponse(ctx context.Context, sessionID string, params *SessionInitParams, body SessionInitJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionInitResponse, error)

	// SessionMessagesWithResponse request
	SessionMessagesWithResponse(ctx context.Context, sessionID string, params *SessionMessagesParams, reqEditors ...RequestEditorFn) (*SessionMessagesResponse, error)

	// SessionPromptWithBodyWithResponse request with any body
	SessionPromptWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionPromptResponse, error)

	SessionPromptWithResponse(ctx context.Context, sessionID string, params *SessionPromptParams, body SessionPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionPromptResponse, error)

	// SessionMessageWithResponse request
	SessionMessageWithResponse(ctx context.Context, sessionID string, messageID string, params *SessionMessageParams, reqEditors ...RequestEditorFn) (*SessionMessageResponse, error)

	// PartDeleteWithResponse request
	PartDeleteWithResponse(ctx context.Context, sessionID string, messageID string, partID string, params *PartDeleteParams, reqEditors ...RequestEditorFn) (*PartDeleteResponse, error)

	// PartUpdateWithBodyWithResponse request with any body
	PartUpdateWithBodyWithResponse(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PartUpdateResponse, error)

	PartUpdateWithResponse(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, body PartUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*PartUpdateResponse, error)

	// PermissionRespondWithBodyWithResponse request with any body
	PermissionRespondWithBodyWithResponse(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PermissionRespondResponse, error)

	PermissionRespondWithResponse(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, body PermissionRespondJSONRequestBody, reqEditors ...RequestEditorFn) (*PermissionRespondResponse, error)

	// SessionPromptAsyncWithBodyWithResponse request with any body
	SessionPromptAsyncWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionPromptAsyncResponse, error)

	SessionPromptAsyncWithResponse(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, body SessionPromptAsyncJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionPromptAsyncResponse, error)

	// SessionRevertWithBodyWithResponse request with any body
	SessionRevertWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionRevertParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionRevertResponse, error)

	SessionRevertWithResponse(ctx context.Context, sessionID string, params *SessionRevertParams, body SessionRevertJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionRevertResponse, error)

	// SessionUnshareWithResponse request
	SessionUnshareWithResponse(ctx context.Context, sessionID string, params *SessionUnshareParams, reqEditors ...RequestEditorFn) (*SessionUnshareResponse, error)

	// SessionShareWithResponse request
	SessionShareWithResponse(ctx context.Context, sessionID string, params *SessionShareParams, reqEditors ...RequestEditorFn) (*SessionShareResponse, error)

	// SessionShellWithBodyWithResponse request with any body
	SessionShellWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionShellParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionShellResponse, error)

	SessionShellWithResponse(ctx context.Context, sessionID string, params *SessionShellParams, body SessionShellJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionShellResponse, error)

	// SessionSummarizeWithBodyWithResponse request with any body
	SessionSummarizeWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionSummarizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionSummarizeResponse, error)

	SessionSummarizeWithResponse(ctx context.Context, sessionID string, params *SessionSummarizeParams, body SessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionSummarizeResponse, error)

	// SessionTodoWithResponse request
	SessionTodoWithResponse(ctx context.Context, sessionID string, params *SessionTodoParams, reqEditors ...RequestEditorFn) (*SessionTodoResponse, error)

	// SessionUnrevertWithResponse request
	SessionUnrevertWithResponse(ctx context.Context, sessionID string, params *SessionUnrevertParams, reqEditors ...RequestEditorFn) (*SessionUnrevertResponse, error)

	// TuiAppendPromptWithBodyWithResponse request with any body
	TuiAppendPromptWithBodyWithResponse(ctx context.Context, params *TuiAppendPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiAppendPromptResponse, error)

	TuiAppendPromptWithResponse(ctx context.Context, params *TuiAppendPromptParams, body TuiAppendPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiAppendPromptResponse, error)

	// TuiClearPromptWithResponse request
	TuiClearPromptWithResponse(ctx context.Context, params *TuiClearPromptParams, reqEditors ...RequestEditorFn) (*TuiClearPromptResponse, error)

	// TuiControlNextWithResponse request
	TuiControlNextWithResponse(ctx context.Context, params *TuiControlNextParams, reqEditors ...RequestEditorFn) (*TuiControlNextResponse, error)

	// TuiControlResponseWithBodyWithResponse request with any body
	TuiControlResponseWithBodyWithResponse(ctx context.Context, params *TuiControlResponseParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiControlResponseResponse, error)

	TuiControlResponseWithResponse(ctx context.Context, params *TuiControlResponseParams, body TuiControlResponseJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiControlResponseResponse, error)

	// TuiExecuteCommandWithBodyWithResponse request with any body
	TuiExecuteCommandWithBodyWithResponse(ctx context.Context, params *TuiExecuteCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiExecuteCommandResponse, error)

	TuiExecuteCommandWithResponse(ctx context.Context, params *TuiExecuteCommandParams, body TuiExecuteCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiExecuteCommandResponse, error)

	// TuiOpenHelpWithResponse request
	TuiOpenHelpWithResponse(ctx context.Context, params *TuiOpenHelpParams, reqEditors ...RequestEditorFn) (*TuiOpenHelpResponse, error)

	// TuiOpenModelsWithResponse request
	TuiOpenModelsWithResponse(ctx context.Context, params *TuiOpenModelsParams, reqEditors ...RequestEditorFn) (*TuiOpenModelsResponse, error)

	// TuiOpenSessionsWithResponse request
	TuiOpenSessionsWithResponse(ctx context.Context, params *TuiOpenSessionsParams, reqEditors ...RequestEditorFn) (*TuiOpenSessionsResponse, error)

	// TuiOpenThemesWithResponse request
	TuiOpenThemesWithResponse(ctx context.Context, params *TuiOpenThemesParams, reqEditors ...RequestEditorFn) (*TuiOpenThemesResponse, error)

	// TuiPublishWithBodyWithResponse request with any body
	TuiPublishWithBodyWithResponse(ctx context.Context, params *TuiPublishParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiPublishResponse, error)

	TuiPublishWithResponse(ctx context.Context, params *TuiPublishParams, body TuiPublishJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiPublishResponse, error)

	// TuiSelectSessionWithBodyWithResponse request with any body
	TuiSelectSessionWithBodyWithResponse(ctx context.Context, params *TuiSelectSessionParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiSelectSessionResponse, error)

	TuiSelectSessionWithResponse(ctx context.Context, params *TuiSelectSessionParams, body TuiSelectSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiSelectSessionResponse, error)

	// TuiShowToastWithBodyWithResponse request with any body
	TuiShowToastWithBodyWithResponse(ctx context.Context, params *TuiShowToastParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiShowToastResponse, error)

	TuiShowToastWithResponse(ctx context.Context, params *TuiShowToastParams, body TuiShowToastJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiShowToastResponse, error)

	// TuiSubmitPromptWithResponse request
	TuiSubmitPromptWithResponse(ctx context.Context, params *TuiSubmitPromptParams, reqEditors ...RequestEditorFn) (*TuiSubmitPromptResponse, error)

	// VcsGetWithResponse request
	VcsGetWithResponse(ctx context.Context, params *VcsGetParams, reqEditors ...RequestEditorFn) (*VcsGetResponse, error)
}

type AppAgentsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Agent
}

// Status returns HTTPResponse.Status
func (r AppAgentsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AppAgentsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AuthSetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r AuthSetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AuthSetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type CommandListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Command
}

// Status returns HTTPResponse.Status
func (r CommandListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r CommandListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ConfigGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Config
}

// Status returns HTTPResponse.Status
func (r ConfigGetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ConfigGetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ConfigUpdateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Config
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r ConfigUpdateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ConfigUpdateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ConfigProvidersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Default   map[string]string `json:"default"`
		Providers []Provider        `json:"providers"`
	}
}

// Status returns HTTPResponse.Status
func (r ConfigProvidersResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ConfigProvidersResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type EventSubscribeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r EventSubscribeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r EventSubscribeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ExperimentalResourceListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]McpResource
}

// Status returns HTTPResponse.Status
func (r ExperimentalResourceListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ExperimentalResourceListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ToolListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ToolList
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r ToolListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ToolListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ToolIdsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ToolIDs
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r ToolIdsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ToolIdsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type WorktreeListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]string
}

// Status returns HTTPResponse.Status
func (r WorktreeListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r WorktreeListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type WorktreeCreateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Worktree
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r WorktreeCreateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r WorktreeCreateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FileListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]FileNode
}

// Status returns HTTPResponse.Status
func (r FileListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FileListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FileReadResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *FileContent
}

// Status returns HTTPResponse.Status
func (r FileReadResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FileReadResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FileStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]File
}

// Status returns HTTPResponse.Status
func (r FileStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FileStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindTextResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]struct {
		AbsoluteOffset float32 `json:"absolute_offset"`
		LineNumber     float32 `json:"line_number"`
		Lines          struct {
			Text string `json:"text"`
		} `json:"lines"`
		Path struct {
			Text string `json:"text"`
		} `json:"path"`
		Submatches []struct {
			End   float32 `json:"end"`
			Match struct {
				Text string `json:"text"`
			} `json:"match"`
			Start float32 `json:"start"`
		} `json:"submatches"`
	}
}

// Status returns HTTPResponse.Status
func (r FindTextResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindTextResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindFilesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]string
}

// Status returns HTTPResponse.Status
func (r FindFilesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindFilesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FindSymbolsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Symbol
}

// Status returns HTTPResponse.Status
func (r FindSymbolsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FindSymbolsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type FormatterStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]FormatterStatus
}

// Status returns HTTPResponse.Status
func (r FormatterStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r FormatterStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GlobalDisposeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r GlobalDisposeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GlobalDisposeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GlobalEventResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r GlobalEventResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GlobalEventResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GlobalHealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Healthy bool   `json:"healthy"`
		Version string `json:"version"`
	}
}

// Status returns HTTPResponse.Status
func (r GlobalHealthResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GlobalHealthResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type InstanceDisposeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r InstanceDisposeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r InstanceDisposeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type AppLogResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r AppLogResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r AppLogResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type LspStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]LSPStatus
}

// Status returns HTTPResponse.Status
func (r LspStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r LspStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]MCPStatus
}

// Status returns HTTPResponse.Status
func (r McpStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpAddResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]MCPStatus
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r McpAddResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpAddResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpAuthRemoveResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Success bool `json:"success"`
	}
	JSON404 *NotFoundError
}

// Status returns HTTPResponse.Status
func (r McpAuthRemoveResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpAuthRemoveResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpAuthStartResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		// AuthorizationUrl URL to open in browser for authorization
		AuthorizationUrl string `json:"authorizationUrl"`
	}
	JSON400 *BadRequestError
	JSON404 *NotFoundError
}

// Status returns HTTPResponse.Status
func (r McpAuthStartResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpAuthStartResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpAuthAuthenticateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *MCPStatus
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r McpAuthAuthenticateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpAuthAuthenticateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpAuthCallbackResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *MCPStatus
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r McpAuthCallbackResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpAuthCallbackResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpConnectResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r McpConnectResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpConnectResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type McpDisconnectResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r McpDisconnectResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r McpDisconnectResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PathGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Path
}

// Status returns HTTPResponse.Status
func (r PathGetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PathGetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PermissionListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]PermissionRequest
}

// Status returns HTTPResponse.Status
func (r PermissionListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PermissionListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PermissionReplyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PermissionReplyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PermissionReplyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProjectListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Project
}

// Status returns HTTPResponse.Status
func (r ProjectListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProjectListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProjectCurrentResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Project
}

// Status returns HTTPResponse.Status
func (r ProjectCurrentResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProjectCurrentResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProjectUpdateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Project
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r ProjectUpdateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProjectUpdateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProviderListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		All []struct {
			Api    *string  `json:"api,omitempty"`
			Env    []string `json:"env"`
			Id     string   `json:"id"`
			Models map[string]struct {
				Attachment bool `json:"attachment"`
				Cost       *struct {
					CacheRead       *float32 `json:"cache_read,omitempty"`
					CacheWrite      *float32 `json:"cache_write,omitempty"`
					ContextOver200k *struct {
						CacheRead  *float32 `json:"cache_read,omitempty"`
						CacheWrite *float32 `json:"cache_write,omitempty"`
						Input      float32  `json:"input"`
						Output     float32  `json:"output"`
					} `json:"context_over_200k,omitempty"`
					Input  float32 `json:"input"`
					Output float32 `json:"output"`
				} `json:"cost,omitempty"`
				Experimental *bool                                    `json:"experimental,omitempty"`
				Family       *string                                  `json:"family,omitempty"`
				Headers      *map[string]string                       `json:"headers,omitempty"`
				Id           string                                   `json:"id"`
				Interleaved  *ProviderList_200_All_Models_Interleaved `json:"interleaved,omitempty"`
				Limit        struct {
					Context float32  `json:"context"`
					Input   *float32 `json:"input,omitempty"`
					Output  float32  `json:"output"`
				} `json:"limit"`
				Modalities *struct {
					Input  []ProviderList200AllModelsModalitiesInput  `json:"input"`
					Output []ProviderList200AllModelsModalitiesOutput `json:"output"`
				} `json:"modalities,omitempty"`
				Name     string                 `json:"name"`
				Options  map[string]interface{} `json:"options"`
				Provider *struct {
					Npm string `json:"npm"`
				} `json:"provider,omitempty"`
				Reasoning   bool                               `json:"reasoning"`
				ReleaseDate string                             `json:"release_date"`
				Status      *ProviderList200AllModelsStatus    `json:"status,omitempty"`
				Temperature bool                               `json:"temperature"`
				ToolCall    bool                               `json:"tool_call"`
				Variants    *map[string]map[string]interface{} `json:"variants,omitempty"`
			} `json:"models"`
			Name string  `json:"name"`
			Npm  *string `json:"npm,omitempty"`
		} `json:"all"`
		Connected []string          `json:"connected"`
		Default   map[string]string `json:"default"`
	}
}
type ProviderList200AllModelsInterleaved0 = bool
type ProviderList200AllModelsInterleaved1 struct {
	Field ProviderList200AllModelsInterleaved1Field `json:"field"`
}
type ProviderList200AllModelsInterleaved1Field string
type ProviderList_200_All_Models_Interleaved struct {
	union json.RawMessage
}
type ProviderList200AllModelsModalitiesInput string
type ProviderList200AllModelsModalitiesOutput string
type ProviderList200AllModelsStatus string

// Status returns HTTPResponse.Status
func (r ProviderListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProviderListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProviderAuthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string][]ProviderAuthMethod
}

// Status returns HTTPResponse.Status
func (r ProviderAuthResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProviderAuthResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProviderOauthAuthorizeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *ProviderAuthAuthorization
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r ProviderOauthAuthorizeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProviderOauthAuthorizeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type ProviderOauthCallbackResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r ProviderOauthCallbackResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r ProviderOauthCallbackResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PtyListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Pty
}

// Status returns HTTPResponse.Status
func (r PtyListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PtyListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PtyCreateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Pty
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r PtyCreateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PtyCreateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PtyRemoveResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PtyRemoveResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PtyRemoveResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PtyGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Pty
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PtyGetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PtyGetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PtyUpdateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Pty
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r PtyUpdateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PtyUpdateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PtyConnectResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PtyConnectResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PtyConnectResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type QuestionListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]QuestionRequest
}

// Status returns HTTPResponse.Status
func (r QuestionListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r QuestionListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type QuestionRejectResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r QuestionRejectResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r QuestionRejectResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type QuestionReplyResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r QuestionReplyResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r QuestionReplyResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Session
}

// Status returns HTTPResponse.Status
func (r SessionListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionCreateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r SessionCreateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionCreateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *map[string]SessionStatus
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r SessionStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionDeleteResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionDeleteResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionDeleteResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionGetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionGetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionUpdateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionUpdateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionUpdateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionAbortResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionAbortResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionAbortResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionChildrenResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionChildrenResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionChildrenResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionCommandResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Info  AssistantMessage `json:"info"`
		Parts []Part           `json:"parts"`
	}
	JSON400 *BadRequestError
	JSON404 *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionCommandResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionCommandResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionDiffResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]FileDiff
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionDiffResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionDiffResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionForkResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
}

// Status returns HTTPResponse.Status
func (r SessionForkResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionForkResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionInitResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionInitResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionInitResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionMessagesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]struct {
		Info  Message `json:"info"`
		Parts []Part  `json:"parts"`
	}
	JSON400 *BadRequestError
	JSON404 *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionMessagesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionMessagesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionPromptResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Info  AssistantMessage `json:"info"`
		Parts []Part           `json:"parts"`
	}
	JSON400 *BadRequestError
	JSON404 *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionPromptResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionPromptResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionMessageResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Info  Message `json:"info"`
		Parts []Part  `json:"parts"`
	}
	JSON400 *BadRequestError
	JSON404 *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionMessageResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionMessageResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PartDeleteResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PartDeleteResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PartDeleteResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PartUpdateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Part
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PartUpdateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PartUpdateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PermissionRespondResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r PermissionRespondResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PermissionRespondResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionPromptAsyncResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionPromptAsyncResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionPromptAsyncResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionRevertResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionRevertResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionRevertResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionUnshareResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionUnshareResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionUnshareResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionShareResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionShareResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionShareResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionShellResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AssistantMessage
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionShellResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionShellResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionSummarizeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionSummarizeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionSummarizeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionTodoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]Todo
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionTodoResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionTodoResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type SessionUnrevertResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Session
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r SessionUnrevertResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r SessionUnrevertResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiAppendPromptResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r TuiAppendPromptResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiAppendPromptResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiClearPromptResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiClearPromptResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiClearPromptResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiControlNextResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Body interface{} `json:"body"`
		Path string      `json:"path"`
	}
}

// Status returns HTTPResponse.Status
func (r TuiControlNextResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiControlNextResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiControlResponseResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiControlResponseResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiControlResponseResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiExecuteCommandResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r TuiExecuteCommandResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiExecuteCommandResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiOpenHelpResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiOpenHelpResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiOpenHelpResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiOpenModelsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiOpenModelsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiOpenModelsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiOpenSessionsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiOpenSessionsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiOpenSessionsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiOpenThemesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiOpenThemesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiOpenThemesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiPublishResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
}

// Status returns HTTPResponse.Status
func (r TuiPublishResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiPublishResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiSelectSessionResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
	JSON400      *BadRequestError
	JSON404      *NotFoundError
}

// Status returns HTTPResponse.Status
func (r TuiSelectSessionResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiSelectSessionResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiShowToastResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiShowToastResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiShowToastResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type TuiSubmitPromptResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r TuiSubmitPromptResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r TuiSubmitPromptResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type VcsGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *VcsInfo
}

// Status returns HTTPResponse.Status
func (r VcsGetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r VcsGetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// AppAgentsWithResponse request returning *AppAgentsResponse
func (c *ClientWithResponses) AppAgentsWithResponse(ctx context.Context, params *AppAgentsParams, reqEditors ...RequestEditorFn) (*AppAgentsResponse, error) {
	rsp, err := c.AppAgents(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAppAgentsResponse(rsp)
}

// AuthSetWithBodyWithResponse request with arbitrary body returning *AuthSetResponse
func (c *ClientWithResponses) AuthSetWithBodyWithResponse(ctx context.Context, providerID string, params *AuthSetParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AuthSetResponse, error) {
	rsp, err := c.AuthSetWithBody(ctx, providerID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAuthSetResponse(rsp)
}

func (c *ClientWithResponses) AuthSetWithResponse(ctx context.Context, providerID string, params *AuthSetParams, body AuthSetJSONRequestBody, reqEditors ...RequestEditorFn) (*AuthSetResponse, error) {
	rsp, err := c.AuthSet(ctx, providerID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAuthSetResponse(rsp)
}

// CommandListWithResponse request returning *CommandListResponse
func (c *ClientWithResponses) CommandListWithResponse(ctx context.Context, params *CommandListParams, reqEditors ...RequestEditorFn) (*CommandListResponse, error) {
	rsp, err := c.CommandList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseCommandListResponse(rsp)
}

// ConfigGetWithResponse request returning *ConfigGetResponse
func (c *ClientWithResponses) ConfigGetWithResponse(ctx context.Context, params *ConfigGetParams, reqEditors ...RequestEditorFn) (*ConfigGetResponse, error) {
	rsp, err := c.ConfigGet(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseConfigGetResponse(rsp)
}

// ConfigUpdateWithBodyWithResponse request with arbitrary body returning *ConfigUpdateResponse
func (c *ClientWithResponses) ConfigUpdateWithBodyWithResponse(ctx context.Context, params *ConfigUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ConfigUpdateResponse, error) {
	rsp, err := c.ConfigUpdateWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseConfigUpdateResponse(rsp)
}

func (c *ClientWithResponses) ConfigUpdateWithResponse(ctx context.Context, params *ConfigUpdateParams, body ConfigUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*ConfigUpdateResponse, error) {
	rsp, err := c.ConfigUpdate(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseConfigUpdateResponse(rsp)
}

// ConfigProvidersWithResponse request returning *ConfigProvidersResponse
func (c *ClientWithResponses) ConfigProvidersWithResponse(ctx context.Context, params *ConfigProvidersParams, reqEditors ...RequestEditorFn) (*ConfigProvidersResponse, error) {
	rsp, err := c.ConfigProviders(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseConfigProvidersResponse(rsp)
}

// EventSubscribeWithResponse request returning *EventSubscribeResponse
func (c *ClientWithResponses) EventSubscribeWithResponse(ctx context.Context, params *EventSubscribeParams, reqEditors ...RequestEditorFn) (*EventSubscribeResponse, error) {
	rsp, err := c.EventSubscribe(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseEventSubscribeResponse(rsp)
}

// ExperimentalResourceListWithResponse request returning *ExperimentalResourceListResponse
func (c *ClientWithResponses) ExperimentalResourceListWithResponse(ctx context.Context, params *ExperimentalResourceListParams, reqEditors ...RequestEditorFn) (*ExperimentalResourceListResponse, error) {
	rsp, err := c.ExperimentalResourceList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseExperimentalResourceListResponse(rsp)
}

// ToolListWithResponse request returning *ToolListResponse
func (c *ClientWithResponses) ToolListWithResponse(ctx context.Context, params *ToolListParams, reqEditors ...RequestEditorFn) (*ToolListResponse, error) {
	rsp, err := c.ToolList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseToolListResponse(rsp)
}

// ToolIdsWithResponse request returning *ToolIdsResponse
func (c *ClientWithResponses) ToolIdsWithResponse(ctx context.Context, params *ToolIdsParams, reqEditors ...RequestEditorFn) (*ToolIdsResponse, error) {
	rsp, err := c.ToolIds(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseToolIdsResponse(rsp)
}

// WorktreeListWithResponse request returning *WorktreeListResponse
func (c *ClientWithResponses) WorktreeListWithResponse(ctx context.Context, params *WorktreeListParams, reqEditors ...RequestEditorFn) (*WorktreeListResponse, error) {
	rsp, err := c.WorktreeList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseWorktreeListResponse(rsp)
}

// WorktreeCreateWithBodyWithResponse request with arbitrary body returning *WorktreeCreateResponse
func (c *ClientWithResponses) WorktreeCreateWithBodyWithResponse(ctx context.Context, params *WorktreeCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*WorktreeCreateResponse, error) {
	rsp, err := c.WorktreeCreateWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseWorktreeCreateResponse(rsp)
}

func (c *ClientWithResponses) WorktreeCreateWithResponse(ctx context.Context, params *WorktreeCreateParams, body WorktreeCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*WorktreeCreateResponse, error) {
	rsp, err := c.WorktreeCreate(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseWorktreeCreateResponse(rsp)
}

// FileListWithResponse request returning *FileListResponse
func (c *ClientWithResponses) FileListWithResponse(ctx context.Context, params *FileListParams, reqEditors ...RequestEditorFn) (*FileListResponse, error) {
	rsp, err := c.FileList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFileListResponse(rsp)
}

// FileReadWithResponse request returning *FileReadResponse
func (c *ClientWithResponses) FileReadWithResponse(ctx context.Context, params *FileReadParams, reqEditors ...RequestEditorFn) (*FileReadResponse, error) {
	rsp, err := c.FileRead(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFileReadResponse(rsp)
}

// FileStatusWithResponse request returning *FileStatusResponse
func (c *ClientWithResponses) FileStatusWithResponse(ctx context.Context, params *FileStatusParams, reqEditors ...RequestEditorFn) (*FileStatusResponse, error) {
	rsp, err := c.FileStatus(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFileStatusResponse(rsp)
}

// FindTextWithResponse request returning *FindTextResponse
func (c *ClientWithResponses) FindTextWithResponse(ctx context.Context, params *FindTextParams, reqEditors ...RequestEditorFn) (*FindTextResponse, error) {
	rsp, err := c.FindText(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindTextResponse(rsp)
}

// FindFilesWithResponse request returning *FindFilesResponse
func (c *ClientWithResponses) FindFilesWithResponse(ctx context.Context, params *FindFilesParams, reqEditors ...RequestEditorFn) (*FindFilesResponse, error) {
	rsp, err := c.FindFiles(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindFilesResponse(rsp)
}

// FindSymbolsWithResponse request returning *FindSymbolsResponse
func (c *ClientWithResponses) FindSymbolsWithResponse(ctx context.Context, params *FindSymbolsParams, reqEditors ...RequestEditorFn) (*FindSymbolsResponse, error) {
	rsp, err := c.FindSymbols(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFindSymbolsResponse(rsp)
}

// FormatterStatusWithResponse request returning *FormatterStatusResponse
func (c *ClientWithResponses) FormatterStatusWithResponse(ctx context.Context, params *FormatterStatusParams, reqEditors ...RequestEditorFn) (*FormatterStatusResponse, error) {
	rsp, err := c.FormatterStatus(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseFormatterStatusResponse(rsp)
}

// GlobalDisposeWithResponse request returning *GlobalDisposeResponse
func (c *ClientWithResponses) GlobalDisposeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GlobalDisposeResponse, error) {
	rsp, err := c.GlobalDispose(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGlobalDisposeResponse(rsp)
}

// GlobalEventWithResponse request returning *GlobalEventResponse
func (c *ClientWithResponses) GlobalEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GlobalEventResponse, error) {
	rsp, err := c.GlobalEvent(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGlobalEventResponse(rsp)
}

// GlobalHealthWithResponse request returning *GlobalHealthResponse
func (c *ClientWithResponses) GlobalHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GlobalHealthResponse, error) {
	rsp, err := c.GlobalHealth(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGlobalHealthResponse(rsp)
}

// InstanceDisposeWithResponse request returning *InstanceDisposeResponse
func (c *ClientWithResponses) InstanceDisposeWithResponse(ctx context.Context, params *InstanceDisposeParams, reqEditors ...RequestEditorFn) (*InstanceDisposeResponse, error) {
	rsp, err := c.InstanceDispose(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseInstanceDisposeResponse(rsp)
}

// AppLogWithBodyWithResponse request with arbitrary body returning *AppLogResponse
func (c *ClientWithResponses) AppLogWithBodyWithResponse(ctx context.Context, params *AppLogParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*AppLogResponse, error) {
	rsp, err := c.AppLogWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAppLogResponse(rsp)
}

func (c *ClientWithResponses) AppLogWithResponse(ctx context.Context, params *AppLogParams, body AppLogJSONRequestBody, reqEditors ...RequestEditorFn) (*AppLogResponse, error) {
	rsp, err := c.AppLog(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseAppLogResponse(rsp)
}

// LspStatusWithResponse request returning *LspStatusResponse
func (c *ClientWithResponses) LspStatusWithResponse(ctx context.Context, params *LspStatusParams, reqEditors ...RequestEditorFn) (*LspStatusResponse, error) {
	rsp, err := c.LspStatus(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseLspStatusResponse(rsp)
}

// McpStatusWithResponse request returning *McpStatusResponse
func (c *ClientWithResponses) McpStatusWithResponse(ctx context.Context, params *McpStatusParams, reqEditors ...RequestEditorFn) (*McpStatusResponse, error) {
	rsp, err := c.McpStatus(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpStatusResponse(rsp)
}

// McpAddWithBodyWithResponse request with arbitrary body returning *McpAddResponse
func (c *ClientWithResponses) McpAddWithBodyWithResponse(ctx context.Context, params *McpAddParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*McpAddResponse, error) {
	rsp, err := c.McpAddWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAddResponse(rsp)
}

func (c *ClientWithResponses) McpAddWithResponse(ctx context.Context, params *McpAddParams, body McpAddJSONRequestBody, reqEditors ...RequestEditorFn) (*McpAddResponse, error) {
	rsp, err := c.McpAdd(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAddResponse(rsp)
}

// McpAuthRemoveWithResponse request returning *McpAuthRemoveResponse
func (c *ClientWithResponses) McpAuthRemoveWithResponse(ctx context.Context, name string, params *McpAuthRemoveParams, reqEditors ...RequestEditorFn) (*McpAuthRemoveResponse, error) {
	rsp, err := c.McpAuthRemove(ctx, name, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAuthRemoveResponse(rsp)
}

// McpAuthStartWithResponse request returning *McpAuthStartResponse
func (c *ClientWithResponses) McpAuthStartWithResponse(ctx context.Context, name string, params *McpAuthStartParams, reqEditors ...RequestEditorFn) (*McpAuthStartResponse, error) {
	rsp, err := c.McpAuthStart(ctx, name, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAuthStartResponse(rsp)
}

// McpAuthAuthenticateWithResponse request returning *McpAuthAuthenticateResponse
func (c *ClientWithResponses) McpAuthAuthenticateWithResponse(ctx context.Context, name string, params *McpAuthAuthenticateParams, reqEditors ...RequestEditorFn) (*McpAuthAuthenticateResponse, error) {
	rsp, err := c.McpAuthAuthenticate(ctx, name, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAuthAuthenticateResponse(rsp)
}

// McpAuthCallbackWithBodyWithResponse request with arbitrary body returning *McpAuthCallbackResponse
func (c *ClientWithResponses) McpAuthCallbackWithBodyWithResponse(ctx context.Context, name string, params *McpAuthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*McpAuthCallbackResponse, error) {
	rsp, err := c.McpAuthCallbackWithBody(ctx, name, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAuthCallbackResponse(rsp)
}

func (c *ClientWithResponses) McpAuthCallbackWithResponse(ctx context.Context, name string, params *McpAuthCallbackParams, body McpAuthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*McpAuthCallbackResponse, error) {
	rsp, err := c.McpAuthCallback(ctx, name, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpAuthCallbackResponse(rsp)
}

// McpConnectWithResponse request returning *McpConnectResponse
func (c *ClientWithResponses) McpConnectWithResponse(ctx context.Context, name string, params *McpConnectParams, reqEditors ...RequestEditorFn) (*McpConnectResponse, error) {
	rsp, err := c.McpConnect(ctx, name, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpConnectResponse(rsp)
}

// McpDisconnectWithResponse request returning *McpDisconnectResponse
func (c *ClientWithResponses) McpDisconnectWithResponse(ctx context.Context, name string, params *McpDisconnectParams, reqEditors ...RequestEditorFn) (*McpDisconnectResponse, error) {
	rsp, err := c.McpDisconnect(ctx, name, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseMcpDisconnectResponse(rsp)
}

// PathGetWithResponse request returning *PathGetResponse
func (c *ClientWithResponses) PathGetWithResponse(ctx context.Context, params *PathGetParams, reqEditors ...RequestEditorFn) (*PathGetResponse, error) {
	rsp, err := c.PathGet(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePathGetResponse(rsp)
}

// PermissionListWithResponse request returning *PermissionListResponse
func (c *ClientWithResponses) PermissionListWithResponse(ctx context.Context, params *PermissionListParams, reqEditors ...RequestEditorFn) (*PermissionListResponse, error) {
	rsp, err := c.PermissionList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePermissionListResponse(rsp)
}

// PermissionReplyWithBodyWithResponse request with arbitrary body returning *PermissionReplyResponse
func (c *ClientWithResponses) PermissionReplyWithBodyWithResponse(ctx context.Context, requestID string, params *PermissionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PermissionReplyResponse, error) {
	rsp, err := c.PermissionReplyWithBody(ctx, requestID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePermissionReplyResponse(rsp)
}

func (c *ClientWithResponses) PermissionReplyWithResponse(ctx context.Context, requestID string, params *PermissionReplyParams, body PermissionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*PermissionReplyResponse, error) {
	rsp, err := c.PermissionReply(ctx, requestID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePermissionReplyResponse(rsp)
}

// ProjectListWithResponse request returning *ProjectListResponse
func (c *ClientWithResponses) ProjectListWithResponse(ctx context.Context, params *ProjectListParams, reqEditors ...RequestEditorFn) (*ProjectListResponse, error) {
	rsp, err := c.ProjectList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProjectListResponse(rsp)
}

// ProjectCurrentWithResponse request returning *ProjectCurrentResponse
func (c *ClientWithResponses) ProjectCurrentWithResponse(ctx context.Context, params *ProjectCurrentParams, reqEditors ...RequestEditorFn) (*ProjectCurrentResponse, error) {
	rsp, err := c.ProjectCurrent(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProjectCurrentResponse(rsp)
}

// ProjectUpdateWithBodyWithResponse request with arbitrary body returning *ProjectUpdateResponse
func (c *ClientWithResponses) ProjectUpdateWithBodyWithResponse(ctx context.Context, projectID string, params *ProjectUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProjectUpdateResponse, error) {
	rsp, err := c.ProjectUpdateWithBody(ctx, projectID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProjectUpdateResponse(rsp)
}

func (c *ClientWithResponses) ProjectUpdateWithResponse(ctx context.Context, projectID string, params *ProjectUpdateParams, body ProjectUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*ProjectUpdateResponse, error) {
	rsp, err := c.ProjectUpdate(ctx, projectID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProjectUpdateResponse(rsp)
}

// ProviderListWithResponse request returning *ProviderListResponse
func (c *ClientWithResponses) ProviderListWithResponse(ctx context.Context, params *ProviderListParams, reqEditors ...RequestEditorFn) (*ProviderListResponse, error) {
	rsp, err := c.ProviderList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProviderListResponse(rsp)
}

// ProviderAuthWithResponse request returning *ProviderAuthResponse
func (c *ClientWithResponses) ProviderAuthWithResponse(ctx context.Context, params *ProviderAuthParams, reqEditors ...RequestEditorFn) (*ProviderAuthResponse, error) {
	rsp, err := c.ProviderAuth(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProviderAuthResponse(rsp)
}

// ProviderOauthAuthorizeWithBodyWithResponse request with arbitrary body returning *ProviderOauthAuthorizeResponse
func (c *ClientWithResponses) ProviderOauthAuthorizeWithBodyWithResponse(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProviderOauthAuthorizeResponse, error) {
	rsp, err := c.ProviderOauthAuthorizeWithBody(ctx, providerID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProviderOauthAuthorizeResponse(rsp)
}

func (c *ClientWithResponses) ProviderOauthAuthorizeWithResponse(ctx context.Context, providerID string, params *ProviderOauthAuthorizeParams, body ProviderOauthAuthorizeJSONRequestBody, reqEditors ...RequestEditorFn) (*ProviderOauthAuthorizeResponse, error) {
	rsp, err := c.ProviderOauthAuthorize(ctx, providerID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProviderOauthAuthorizeResponse(rsp)
}

// ProviderOauthCallbackWithBodyWithResponse request with arbitrary body returning *ProviderOauthCallbackResponse
func (c *ClientWithResponses) ProviderOauthCallbackWithBodyWithResponse(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ProviderOauthCallbackResponse, error) {
	rsp, err := c.ProviderOauthCallbackWithBody(ctx, providerID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProviderOauthCallbackResponse(rsp)
}

func (c *ClientWithResponses) ProviderOauthCallbackWithResponse(ctx context.Context, providerID string, params *ProviderOauthCallbackParams, body ProviderOauthCallbackJSONRequestBody, reqEditors ...RequestEditorFn) (*ProviderOauthCallbackResponse, error) {
	rsp, err := c.ProviderOauthCallback(ctx, providerID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseProviderOauthCallbackResponse(rsp)
}

// PtyListWithResponse request returning *PtyListResponse
func (c *ClientWithResponses) PtyListWithResponse(ctx context.Context, params *PtyListParams, reqEditors ...RequestEditorFn) (*PtyListResponse, error) {
	rsp, err := c.PtyList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyListResponse(rsp)
}

// PtyCreateWithBodyWithResponse request with arbitrary body returning *PtyCreateResponse
func (c *ClientWithResponses) PtyCreateWithBodyWithResponse(ctx context.Context, params *PtyCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PtyCreateResponse, error) {
	rsp, err := c.PtyCreateWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyCreateResponse(rsp)
}

func (c *ClientWithResponses) PtyCreateWithResponse(ctx context.Context, params *PtyCreateParams, body PtyCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*PtyCreateResponse, error) {
	rsp, err := c.PtyCreate(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyCreateResponse(rsp)
}

// PtyRemoveWithResponse request returning *PtyRemoveResponse
func (c *ClientWithResponses) PtyRemoveWithResponse(ctx context.Context, ptyID string, params *PtyRemoveParams, reqEditors ...RequestEditorFn) (*PtyRemoveResponse, error) {
	rsp, err := c.PtyRemove(ctx, ptyID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyRemoveResponse(rsp)
}

// PtyGetWithResponse request returning *PtyGetResponse
func (c *ClientWithResponses) PtyGetWithResponse(ctx context.Context, ptyID string, params *PtyGetParams, reqEditors ...RequestEditorFn) (*PtyGetResponse, error) {
	rsp, err := c.PtyGet(ctx, ptyID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyGetResponse(rsp)
}

// PtyUpdateWithBodyWithResponse request with arbitrary body returning *PtyUpdateResponse
func (c *ClientWithResponses) PtyUpdateWithBodyWithResponse(ctx context.Context, ptyID string, params *PtyUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PtyUpdateResponse, error) {
	rsp, err := c.PtyUpdateWithBody(ctx, ptyID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyUpdateResponse(rsp)
}

func (c *ClientWithResponses) PtyUpdateWithResponse(ctx context.Context, ptyID string, params *PtyUpdateParams, body PtyUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*PtyUpdateResponse, error) {
	rsp, err := c.PtyUpdate(ctx, ptyID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyUpdateResponse(rsp)
}

// PtyConnectWithResponse request returning *PtyConnectResponse
func (c *ClientWithResponses) PtyConnectWithResponse(ctx context.Context, ptyID string, params *PtyConnectParams, reqEditors ...RequestEditorFn) (*PtyConnectResponse, error) {
	rsp, err := c.PtyConnect(ctx, ptyID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePtyConnectResponse(rsp)
}

// QuestionListWithResponse request returning *QuestionListResponse
func (c *ClientWithResponses) QuestionListWithResponse(ctx context.Context, params *QuestionListParams, reqEditors ...RequestEditorFn) (*QuestionListResponse, error) {
	rsp, err := c.QuestionList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseQuestionListResponse(rsp)
}

// QuestionRejectWithResponse request returning *QuestionRejectResponse
func (c *ClientWithResponses) QuestionRejectWithResponse(ctx context.Context, requestID string, params *QuestionRejectParams, reqEditors ...RequestEditorFn) (*QuestionRejectResponse, error) {
	rsp, err := c.QuestionReject(ctx, requestID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseQuestionRejectResponse(rsp)
}

// QuestionReplyWithBodyWithResponse request with arbitrary body returning *QuestionReplyResponse
func (c *ClientWithResponses) QuestionReplyWithBodyWithResponse(ctx context.Context, requestID string, params *QuestionReplyParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*QuestionReplyResponse, error) {
	rsp, err := c.QuestionReplyWithBody(ctx, requestID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseQuestionReplyResponse(rsp)
}

func (c *ClientWithResponses) QuestionReplyWithResponse(ctx context.Context, requestID string, params *QuestionReplyParams, body QuestionReplyJSONRequestBody, reqEditors ...RequestEditorFn) (*QuestionReplyResponse, error) {
	rsp, err := c.QuestionReply(ctx, requestID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseQuestionReplyResponse(rsp)
}

// SessionListWithResponse request returning *SessionListResponse
func (c *ClientWithResponses) SessionListWithResponse(ctx context.Context, params *SessionListParams, reqEditors ...RequestEditorFn) (*SessionListResponse, error) {
	rsp, err := c.SessionList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionListResponse(rsp)
}

// SessionCreateWithBodyWithResponse request with arbitrary body returning *SessionCreateResponse
func (c *ClientWithResponses) SessionCreateWithBodyWithResponse(ctx context.Context, params *SessionCreateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionCreateResponse, error) {
	rsp, err := c.SessionCreateWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionCreateResponse(rsp)
}

func (c *ClientWithResponses) SessionCreateWithResponse(ctx context.Context, params *SessionCreateParams, body SessionCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionCreateResponse, error) {
	rsp, err := c.SessionCreate(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionCreateResponse(rsp)
}

// SessionStatusWithResponse request returning *SessionStatusResponse
func (c *ClientWithResponses) SessionStatusWithResponse(ctx context.Context, params *SessionStatusParams, reqEditors ...RequestEditorFn) (*SessionStatusResponse, error) {
	rsp, err := c.SessionStatus(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionStatusResponse(rsp)
}

// SessionDeleteWithResponse request returning *SessionDeleteResponse
func (c *ClientWithResponses) SessionDeleteWithResponse(ctx context.Context, sessionID string, params *SessionDeleteParams, reqEditors ...RequestEditorFn) (*SessionDeleteResponse, error) {
	rsp, err := c.SessionDelete(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionDeleteResponse(rsp)
}

// SessionGetWithResponse request returning *SessionGetResponse
func (c *ClientWithResponses) SessionGetWithResponse(ctx context.Context, sessionID string, params *SessionGetParams, reqEditors ...RequestEditorFn) (*SessionGetResponse, error) {
	rsp, err := c.SessionGet(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionGetResponse(rsp)
}

// SessionUpdateWithBodyWithResponse request with arbitrary body returning *SessionUpdateResponse
func (c *ClientWithResponses) SessionUpdateWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionUpdateResponse, error) {
	rsp, err := c.SessionUpdateWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionUpdateResponse(rsp)
}

func (c *ClientWithResponses) SessionUpdateWithResponse(ctx context.Context, sessionID string, params *SessionUpdateParams, body SessionUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionUpdateResponse, error) {
	rsp, err := c.SessionUpdate(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionUpdateResponse(rsp)
}

// SessionAbortWithResponse request returning *SessionAbortResponse
func (c *ClientWithResponses) SessionAbortWithResponse(ctx context.Context, sessionID string, params *SessionAbortParams, reqEditors ...RequestEditorFn) (*SessionAbortResponse, error) {
	rsp, err := c.SessionAbort(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionAbortResponse(rsp)
}

// SessionChildrenWithResponse request returning *SessionChildrenResponse
func (c *ClientWithResponses) SessionChildrenWithResponse(ctx context.Context, sessionID string, params *SessionChildrenParams, reqEditors ...RequestEditorFn) (*SessionChildrenResponse, error) {
	rsp, err := c.SessionChildren(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionChildrenResponse(rsp)
}

// SessionCommandWithBodyWithResponse request with arbitrary body returning *SessionCommandResponse
func (c *ClientWithResponses) SessionCommandWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionCommandResponse, error) {
	rsp, err := c.SessionCommandWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionCommandResponse(rsp)
}

func (c *ClientWithResponses) SessionCommandWithResponse(ctx context.Context, sessionID string, params *SessionCommandParams, body SessionCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionCommandResponse, error) {
	rsp, err := c.SessionCommand(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionCommandResponse(rsp)
}

// SessionDiffWithResponse request returning *SessionDiffResponse
func (c *ClientWithResponses) SessionDiffWithResponse(ctx context.Context, sessionID string, params *SessionDiffParams, reqEditors ...RequestEditorFn) (*SessionDiffResponse, error) {
	rsp, err := c.SessionDiff(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionDiffResponse(rsp)
}

// SessionForkWithBodyWithResponse request with arbitrary body returning *SessionForkResponse
func (c *ClientWithResponses) SessionForkWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionForkParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionForkResponse, error) {
	rsp, err := c.SessionForkWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionForkResponse(rsp)
}

func (c *ClientWithResponses) SessionForkWithResponse(ctx context.Context, sessionID string, params *SessionForkParams, body SessionForkJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionForkResponse, error) {
	rsp, err := c.SessionFork(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionForkResponse(rsp)
}

// SessionInitWithBodyWithResponse request with arbitrary body returning *SessionInitResponse
func (c *ClientWithResponses) SessionInitWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionInitParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionInitResponse, error) {
	rsp, err := c.SessionInitWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionInitResponse(rsp)
}

func (c *ClientWithResponses) SessionInitWithResponse(ctx context.Context, sessionID string, params *SessionInitParams, body SessionInitJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionInitResponse, error) {
	rsp, err := c.SessionInit(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionInitResponse(rsp)
}

// SessionMessagesWithResponse request returning *SessionMessagesResponse
func (c *ClientWithResponses) SessionMessagesWithResponse(ctx context.Context, sessionID string, params *SessionMessagesParams, reqEditors ...RequestEditorFn) (*SessionMessagesResponse, error) {
	rsp, err := c.SessionMessages(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionMessagesResponse(rsp)
}

// SessionPromptWithBodyWithResponse request with arbitrary body returning *SessionPromptResponse
func (c *ClientWithResponses) SessionPromptWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionPromptResponse, error) {
	rsp, err := c.SessionPromptWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionPromptResponse(rsp)
}

func (c *ClientWithResponses) SessionPromptWithResponse(ctx context.Context, sessionID string, params *SessionPromptParams, body SessionPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionPromptResponse, error) {
	rsp, err := c.SessionPrompt(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionPromptResponse(rsp)
}

// SessionMessageWithResponse request returning *SessionMessageResponse
func (c *ClientWithResponses) SessionMessageWithResponse(ctx context.Context, sessionID string, messageID string, params *SessionMessageParams, reqEditors ...RequestEditorFn) (*SessionMessageResponse, error) {
	rsp, err := c.SessionMessage(ctx, sessionID, messageID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionMessageResponse(rsp)
}

// PartDeleteWithResponse request returning *PartDeleteResponse
func (c *ClientWithResponses) PartDeleteWithResponse(ctx context.Context, sessionID string, messageID string, partID string, params *PartDeleteParams, reqEditors ...RequestEditorFn) (*PartDeleteResponse, error) {
	rsp, err := c.PartDelete(ctx, sessionID, messageID, partID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePartDeleteResponse(rsp)
}

// PartUpdateWithBodyWithResponse request with arbitrary body returning *PartUpdateResponse
func (c *ClientWithResponses) PartUpdateWithBodyWithResponse(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PartUpdateResponse, error) {
	rsp, err := c.PartUpdateWithBody(ctx, sessionID, messageID, partID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePartUpdateResponse(rsp)
}

func (c *ClientWithResponses) PartUpdateWithResponse(ctx context.Context, sessionID string, messageID string, partID string, params *PartUpdateParams, body PartUpdateJSONRequestBody, reqEditors ...RequestEditorFn) (*PartUpdateResponse, error) {
	rsp, err := c.PartUpdate(ctx, sessionID, messageID, partID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePartUpdateResponse(rsp)
}

// PermissionRespondWithBodyWithResponse request with arbitrary body returning *PermissionRespondResponse
func (c *ClientWithResponses) PermissionRespondWithBodyWithResponse(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PermissionRespondResponse, error) {
	rsp, err := c.PermissionRespondWithBody(ctx, sessionID, permissionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePermissionRespondResponse(rsp)
}

func (c *ClientWithResponses) PermissionRespondWithResponse(ctx context.Context, sessionID string, permissionID string, params *PermissionRespondParams, body PermissionRespondJSONRequestBody, reqEditors ...RequestEditorFn) (*PermissionRespondResponse, error) {
	rsp, err := c.PermissionRespond(ctx, sessionID, permissionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePermissionRespondResponse(rsp)
}

// SessionPromptAsyncWithBodyWithResponse request with arbitrary body returning *SessionPromptAsyncResponse
func (c *ClientWithResponses) SessionPromptAsyncWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionPromptAsyncResponse, error) {
	rsp, err := c.SessionPromptAsyncWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionPromptAsyncResponse(rsp)
}

func (c *ClientWithResponses) SessionPromptAsyncWithResponse(ctx context.Context, sessionID string, params *SessionPromptAsyncParams, body SessionPromptAsyncJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionPromptAsyncResponse, error) {
	rsp, err := c.SessionPromptAsync(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionPromptAsyncResponse(rsp)
}

// SessionRevertWithBodyWithResponse request with arbitrary body returning *SessionRevertResponse
func (c *ClientWithResponses) SessionRevertWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionRevertParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionRevertResponse, error) {
	rsp, err := c.SessionRevertWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionRevertResponse(rsp)
}

func (c *ClientWithResponses) SessionRevertWithResponse(ctx context.Context, sessionID string, params *SessionRevertParams, body SessionRevertJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionRevertResponse, error) {
	rsp, err := c.SessionRevert(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionRevertResponse(rsp)
}

// SessionUnshareWithResponse request returning *SessionUnshareResponse
func (c *ClientWithResponses) SessionUnshareWithResponse(ctx context.Context, sessionID string, params *SessionUnshareParams, reqEditors ...RequestEditorFn) (*SessionUnshareResponse, error) {
	rsp, err := c.SessionUnshare(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionUnshareResponse(rsp)
}

// SessionShareWithResponse request returning *SessionShareResponse
func (c *ClientWithResponses) SessionShareWithResponse(ctx context.Context, sessionID string, params *SessionShareParams, reqEditors ...RequestEditorFn) (*SessionShareResponse, error) {
	rsp, err := c.SessionShare(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionShareResponse(rsp)
}

// SessionShellWithBodyWithResponse request with arbitrary body returning *SessionShellResponse
func (c *ClientWithResponses) SessionShellWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionShellParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionShellResponse, error) {
	rsp, err := c.SessionShellWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionShellResponse(rsp)
}

func (c *ClientWithResponses) SessionShellWithResponse(ctx context.Context, sessionID string, params *SessionShellParams, body SessionShellJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionShellResponse, error) {
	rsp, err := c.SessionShell(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionShellResponse(rsp)
}

// SessionSummarizeWithBodyWithResponse request with arbitrary body returning *SessionSummarizeResponse
func (c *ClientWithResponses) SessionSummarizeWithBodyWithResponse(ctx context.Context, sessionID string, params *SessionSummarizeParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SessionSummarizeResponse, error) {
	rsp, err := c.SessionSummarizeWithBody(ctx, sessionID, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionSummarizeResponse(rsp)
}

func (c *ClientWithResponses) SessionSummarizeWithResponse(ctx context.Context, sessionID string, params *SessionSummarizeParams, body SessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*SessionSummarizeResponse, error) {
	rsp, err := c.SessionSummarize(ctx, sessionID, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionSummarizeResponse(rsp)
}

// SessionTodoWithResponse request returning *SessionTodoResponse
func (c *ClientWithResponses) SessionTodoWithResponse(ctx context.Context, sessionID string, params *SessionTodoParams, reqEditors ...RequestEditorFn) (*SessionTodoResponse, error) {
	rsp, err := c.SessionTodo(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionTodoResponse(rsp)
}

// SessionUnrevertWithResponse request returning *SessionUnrevertResponse
func (c *ClientWithResponses) SessionUnrevertWithResponse(ctx context.Context, sessionID string, params *SessionUnrevertParams, reqEditors ...RequestEditorFn) (*SessionUnrevertResponse, error) {
	rsp, err := c.SessionUnrevert(ctx, sessionID, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseSessionUnrevertResponse(rsp)
}

// TuiAppendPromptWithBodyWithResponse request with arbitrary body returning *TuiAppendPromptResponse
func (c *ClientWithResponses) TuiAppendPromptWithBodyWithResponse(ctx context.Context, params *TuiAppendPromptParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiAppendPromptResponse, error) {
	rsp, err := c.TuiAppendPromptWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiAppendPromptResponse(rsp)
}

func (c *ClientWithResponses) TuiAppendPromptWithResponse(ctx context.Context, params *TuiAppendPromptParams, body TuiAppendPromptJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiAppendPromptResponse, error) {
	rsp, err := c.TuiAppendPrompt(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiAppendPromptResponse(rsp)
}

// TuiClearPromptWithResponse request returning *TuiClearPromptResponse
func (c *ClientWithResponses) TuiClearPromptWithResponse(ctx context.Context, params *TuiClearPromptParams, reqEditors ...RequestEditorFn) (*TuiClearPromptResponse, error) {
	rsp, err := c.TuiClearPrompt(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiClearPromptResponse(rsp)
}

// TuiControlNextWithResponse request returning *TuiControlNextResponse
func (c *ClientWithResponses) TuiControlNextWithResponse(ctx context.Context, params *TuiControlNextParams, reqEditors ...RequestEditorFn) (*TuiControlNextResponse, error) {
	rsp, err := c.TuiControlNext(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiControlNextResponse(rsp)
}

// TuiControlResponseWithBodyWithResponse request with arbitrary body returning *TuiControlResponseResponse
func (c *ClientWithResponses) TuiControlResponseWithBodyWithResponse(ctx context.Context, params *TuiControlResponseParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiControlResponseResponse, error) {
	rsp, err := c.TuiControlResponseWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiControlResponseResponse(rsp)
}

func (c *ClientWithResponses) TuiControlResponseWithResponse(ctx context.Context, params *TuiControlResponseParams, body TuiControlResponseJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiControlResponseResponse, error) {
	rsp, err := c.TuiControlResponse(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiControlResponseResponse(rsp)
}

// TuiExecuteCommandWithBodyWithResponse request with arbitrary body returning *TuiExecuteCommandResponse
func (c *ClientWithResponses) TuiExecuteCommandWithBodyWithResponse(ctx context.Context, params *TuiExecuteCommandParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiExecuteCommandResponse, error) {
	rsp, err := c.TuiExecuteCommandWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiExecuteCommandResponse(rsp)
}

func (c *ClientWithResponses) TuiExecuteCommandWithResponse(ctx context.Context, params *TuiExecuteCommandParams, body TuiExecuteCommandJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiExecuteCommandResponse, error) {
	rsp, err := c.TuiExecuteCommand(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiExecuteCommandResponse(rsp)
}

// TuiOpenHelpWithResponse request returning *TuiOpenHelpResponse
func (c *ClientWithResponses) TuiOpenHelpWithResponse(ctx context.Context, params *TuiOpenHelpParams, reqEditors ...RequestEditorFn) (*TuiOpenHelpResponse, error) {
	rsp, err := c.TuiOpenHelp(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiOpenHelpResponse(rsp)
}

// TuiOpenModelsWithResponse request returning *TuiOpenModelsResponse
func (c *ClientWithResponses) TuiOpenModelsWithResponse(ctx context.Context, params *TuiOpenModelsParams, reqEditors ...RequestEditorFn) (*TuiOpenModelsResponse, error) {
	rsp, err := c.TuiOpenModels(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiOpenModelsResponse(rsp)
}

// TuiOpenSessionsWithResponse request returning *TuiOpenSessionsResponse
func (c *ClientWithResponses) TuiOpenSessionsWithResponse(ctx context.Context, params *TuiOpenSessionsParams, reqEditors ...RequestEditorFn) (*TuiOpenSessionsResponse, error) {
	rsp, err := c.TuiOpenSessions(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiOpenSessionsResponse(rsp)
}

// TuiOpenThemesWithResponse request returning *TuiOpenThemesResponse
func (c *ClientWithResponses) TuiOpenThemesWithResponse(ctx context.Context, params *TuiOpenThemesParams, reqEditors ...RequestEditorFn) (*TuiOpenThemesResponse, error) {
	rsp, err := c.TuiOpenThemes(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiOpenThemesResponse(rsp)
}

// TuiPublishWithBodyWithResponse request with arbitrary body returning *TuiPublishResponse
func (c *ClientWithResponses) TuiPublishWithBodyWithResponse(ctx context.Context, params *TuiPublishParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiPublishResponse, error) {
	rsp, err := c.TuiPublishWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiPublishResponse(rsp)
}

func (c *ClientWithResponses) TuiPublishWithResponse(ctx context.Context, params *TuiPublishParams, body TuiPublishJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiPublishResponse, error) {
	rsp, err := c.TuiPublish(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiPublishResponse(rsp)
}

// TuiSelectSessionWithBodyWithResponse request with arbitrary body returning *TuiSelectSessionResponse
func (c *ClientWithResponses) TuiSelectSessionWithBodyWithResponse(ctx context.Context, params *TuiSelectSessionParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiSelectSessionResponse, error) {
	rsp, err := c.TuiSelectSessionWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiSelectSessionResponse(rsp)
}

func (c *ClientWithResponses) TuiSelectSessionWithResponse(ctx context.Context, params *TuiSelectSessionParams, body TuiSelectSessionJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiSelectSessionResponse, error) {
	rsp, err := c.TuiSelectSession(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiSelectSessionResponse(rsp)
}

// TuiShowToastWithBodyWithResponse request with arbitrary body returning *TuiShowToastResponse
func (c *ClientWithResponses) TuiShowToastWithBodyWithResponse(ctx context.Context, params *TuiShowToastParams, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*TuiShowToastResponse, error) {
	rsp, err := c.TuiShowToastWithBody(ctx, params, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiShowToastResponse(rsp)
}

func (c *ClientWithResponses) TuiShowToastWithResponse(ctx context.Context, params *TuiShowToastParams, body TuiShowToastJSONRequestBody, reqEditors ...RequestEditorFn) (*TuiShowToastResponse, error) {
	rsp, err := c.TuiShowToast(ctx, params, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiShowToastResponse(rsp)
}

// TuiSubmitPromptWithResponse request returning *TuiSubmitPromptResponse
func (c *ClientWithResponses) TuiSubmitPromptWithResponse(ctx context.Context, params *TuiSubmitPromptParams, reqEditors ...RequestEditorFn) (*TuiSubmitPromptResponse, error) {
	rsp, err := c.TuiSubmitPrompt(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseTuiSubmitPromptResponse(rsp)
}

// VcsGetWithResponse request returning *VcsGetResponse
func (c *ClientWithResponses) VcsGetWithResponse(ctx context.Context, params *VcsGetParams, reqEditors ...RequestEditorFn) (*VcsGetResponse, error) {
	rsp, err := c.VcsGet(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseVcsGetResponse(rsp)
}

// ParseAppAgentsResponse parses an HTTP response from a AppAgentsWithResponse call
func ParseAppAgentsResponse(rsp *http.Response) (*AppAgentsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &AppAgentsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Agent
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAuthSetResponse parses an HTTP response from a AuthSetWithResponse call
func ParseAuthSetResponse(rsp *http.Response) (*AuthSetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &AuthSetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseCommandListResponse parses an HTTP response from a CommandListWithResponse call
func ParseCommandListResponse(rsp *http.Response) (*CommandListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &CommandListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Command
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseConfigGetResponse parses an HTTP response from a ConfigGetWithResponse call
func ParseConfigGetResponse(rsp *http.Response) (*ConfigGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ConfigGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Config
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseConfigUpdateResponse parses an HTTP response from a ConfigUpdateWithResponse call
func ParseConfigUpdateResponse(rsp *http.Response) (*ConfigUpdateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ConfigUpdateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Config
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseConfigProvidersResponse parses an HTTP response from a ConfigProvidersWithResponse call
func ParseConfigProvidersResponse(rsp *http.Response) (*ConfigProvidersResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ConfigProvidersResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Default   map[string]string `json:"default"`
			Providers []Provider        `json:"providers"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseEventSubscribeResponse parses an HTTP response from a EventSubscribeWithResponse call
func ParseEventSubscribeResponse(rsp *http.Response) (*EventSubscribeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &EventSubscribeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseExperimentalResourceListResponse parses an HTTP response from a ExperimentalResourceListWithResponse call
func ParseExperimentalResourceListResponse(rsp *http.Response) (*ExperimentalResourceListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ExperimentalResourceListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]McpResource
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseToolListResponse parses an HTTP response from a ToolListWithResponse call
func ParseToolListResponse(rsp *http.Response) (*ToolListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ToolListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ToolList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseToolIdsResponse parses an HTTP response from a ToolIdsWithResponse call
func ParseToolIdsResponse(rsp *http.Response) (*ToolIdsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ToolIdsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ToolIDs
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseWorktreeListResponse parses an HTTP response from a WorktreeListWithResponse call
func ParseWorktreeListResponse(rsp *http.Response) (*WorktreeListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &WorktreeListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []string
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseWorktreeCreateResponse parses an HTTP response from a WorktreeCreateWithResponse call
func ParseWorktreeCreateResponse(rsp *http.Response) (*WorktreeCreateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &WorktreeCreateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Worktree
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseFileListResponse parses an HTTP response from a FileListWithResponse call
func ParseFileListResponse(rsp *http.Response) (*FileListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FileListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []FileNode
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFileReadResponse parses an HTTP response from a FileReadWithResponse call
func ParseFileReadResponse(rsp *http.Response) (*FileReadResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FileReadResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest FileContent
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFileStatusResponse parses an HTTP response from a FileStatusWithResponse call
func ParseFileStatusResponse(rsp *http.Response) (*FileStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FileStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []File
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindTextResponse parses an HTTP response from a FindTextWithResponse call
func ParseFindTextResponse(rsp *http.Response) (*FindTextResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FindTextResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []struct {
			AbsoluteOffset float32 `json:"absolute_offset"`
			LineNumber     float32 `json:"line_number"`
			Lines          struct {
				Text string `json:"text"`
			} `json:"lines"`
			Path struct {
				Text string `json:"text"`
			} `json:"path"`
			Submatches []struct {
				End   float32 `json:"end"`
				Match struct {
					Text string `json:"text"`
				} `json:"match"`
				Start float32 `json:"start"`
			} `json:"submatches"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindFilesResponse parses an HTTP response from a FindFilesWithResponse call
func ParseFindFilesResponse(rsp *http.Response) (*FindFilesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FindFilesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []string
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFindSymbolsResponse parses an HTTP response from a FindSymbolsWithResponse call
func ParseFindSymbolsResponse(rsp *http.Response) (*FindSymbolsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FindSymbolsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Symbol
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseFormatterStatusResponse parses an HTTP response from a FormatterStatusWithResponse call
func ParseFormatterStatusResponse(rsp *http.Response) (*FormatterStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &FormatterStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []FormatterStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGlobalDisposeResponse parses an HTTP response from a GlobalDisposeWithResponse call
func ParseGlobalDisposeResponse(rsp *http.Response) (*GlobalDisposeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GlobalDisposeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseGlobalEventResponse parses an HTTP response from a GlobalEventWithResponse call
func ParseGlobalEventResponse(rsp *http.Response) (*GlobalEventResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GlobalEventResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseGlobalHealthResponse parses an HTTP response from a GlobalHealthWithResponse call
func ParseGlobalHealthResponse(rsp *http.Response) (*GlobalHealthResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GlobalHealthResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Healthy bool   `json:"healthy"`
			Version string `json:"version"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseInstanceDisposeResponse parses an HTTP response from a InstanceDisposeWithResponse call
func ParseInstanceDisposeResponse(rsp *http.Response) (*InstanceDisposeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &InstanceDisposeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseAppLogResponse parses an HTTP response from a AppLogWithResponse call
func ParseAppLogResponse(rsp *http.Response) (*AppLogResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &AppLogResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseLspStatusResponse parses an HTTP response from a LspStatusWithResponse call
func ParseLspStatusResponse(rsp *http.Response) (*LspStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &LspStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []LSPStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseMcpStatusResponse parses an HTTP response from a McpStatusWithResponse call
func ParseMcpStatusResponse(rsp *http.Response) (*McpStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]MCPStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseMcpAddResponse parses an HTTP response from a McpAddWithResponse call
func ParseMcpAddResponse(rsp *http.Response) (*McpAddResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpAddResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]MCPStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseMcpAuthRemoveResponse parses an HTTP response from a McpAuthRemoveWithResponse call
func ParseMcpAuthRemoveResponse(rsp *http.Response) (*McpAuthRemoveResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpAuthRemoveResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Success bool `json:"success"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseMcpAuthStartResponse parses an HTTP response from a McpAuthStartWithResponse call
func ParseMcpAuthStartResponse(rsp *http.Response) (*McpAuthStartResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpAuthStartResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			// AuthorizationUrl URL to open in browser for authorization
			AuthorizationUrl string `json:"authorizationUrl"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseMcpAuthAuthenticateResponse parses an HTTP response from a McpAuthAuthenticateWithResponse call
func ParseMcpAuthAuthenticateResponse(rsp *http.Response) (*McpAuthAuthenticateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpAuthAuthenticateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest MCPStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseMcpAuthCallbackResponse parses an HTTP response from a McpAuthCallbackWithResponse call
func ParseMcpAuthCallbackResponse(rsp *http.Response) (*McpAuthCallbackResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpAuthCallbackResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest MCPStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseMcpConnectResponse parses an HTTP response from a McpConnectWithResponse call
func ParseMcpConnectResponse(rsp *http.Response) (*McpConnectResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpConnectResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseMcpDisconnectResponse parses an HTTP response from a McpDisconnectWithResponse call
func ParseMcpDisconnectResponse(rsp *http.Response) (*McpDisconnectResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &McpDisconnectResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePathGetResponse parses an HTTP response from a PathGetWithResponse call
func ParsePathGetResponse(rsp *http.Response) (*PathGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PathGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Path
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePermissionListResponse parses an HTTP response from a PermissionListWithResponse call
func ParsePermissionListResponse(rsp *http.Response) (*PermissionListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PermissionListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []PermissionRequest
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePermissionReplyResponse parses an HTTP response from a PermissionReplyWithResponse call
func ParsePermissionReplyResponse(rsp *http.Response) (*PermissionReplyResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PermissionReplyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseProjectListResponse parses an HTTP response from a ProjectListWithResponse call
func ParseProjectListResponse(rsp *http.Response) (*ProjectListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProjectListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Project
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseProjectCurrentResponse parses an HTTP response from a ProjectCurrentWithResponse call
func ParseProjectCurrentResponse(rsp *http.Response) (*ProjectCurrentResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProjectCurrentResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Project
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseProjectUpdateResponse parses an HTTP response from a ProjectUpdateWithResponse call
func ParseProjectUpdateResponse(rsp *http.Response) (*ProjectUpdateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProjectUpdateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Project
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseProviderListResponse parses an HTTP response from a ProviderListWithResponse call
func ParseProviderListResponse(rsp *http.Response) (*ProviderListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProviderListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			All []struct {
				Api    *string  `json:"api,omitempty"`
				Env    []string `json:"env"`
				Id     string   `json:"id"`
				Models map[string]struct {
					Attachment bool `json:"attachment"`
					Cost       *struct {
						CacheRead       *float32 `json:"cache_read,omitempty"`
						CacheWrite      *float32 `json:"cache_write,omitempty"`
						ContextOver200k *struct {
							CacheRead  *float32 `json:"cache_read,omitempty"`
							CacheWrite *float32 `json:"cache_write,omitempty"`
							Input      float32  `json:"input"`
							Output     float32  `json:"output"`
						} `json:"context_over_200k,omitempty"`
						Input  float32 `json:"input"`
						Output float32 `json:"output"`
					} `json:"cost,omitempty"`
					Experimental *bool                                    `json:"experimental,omitempty"`
					Family       *string                                  `json:"family,omitempty"`
					Headers      *map[string]string                       `json:"headers,omitempty"`
					Id           string                                   `json:"id"`
					Interleaved  *ProviderList_200_All_Models_Interleaved `json:"interleaved,omitempty"`
					Limit        struct {
						Context float32  `json:"context"`
						Input   *float32 `json:"input,omitempty"`
						Output  float32  `json:"output"`
					} `json:"limit"`
					Modalities *struct {
						Input  []ProviderList200AllModelsModalitiesInput  `json:"input"`
						Output []ProviderList200AllModelsModalitiesOutput `json:"output"`
					} `json:"modalities,omitempty"`
					Name     string                 `json:"name"`
					Options  map[string]interface{} `json:"options"`
					Provider *struct {
						Npm string `json:"npm"`
					} `json:"provider,omitempty"`
					Reasoning   bool                               `json:"reasoning"`
					ReleaseDate string                             `json:"release_date"`
					Status      *ProviderList200AllModelsStatus    `json:"status,omitempty"`
					Temperature bool                               `json:"temperature"`
					ToolCall    bool                               `json:"tool_call"`
					Variants    *map[string]map[string]interface{} `json:"variants,omitempty"`
				} `json:"models"`
				Name string  `json:"name"`
				Npm  *string `json:"npm,omitempty"`
			} `json:"all"`
			Connected []string          `json:"connected"`
			Default   map[string]string `json:"default"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseProviderAuthResponse parses an HTTP response from a ProviderAuthWithResponse call
func ParseProviderAuthResponse(rsp *http.Response) (*ProviderAuthResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProviderAuthResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string][]ProviderAuthMethod
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseProviderOauthAuthorizeResponse parses an HTTP response from a ProviderOauthAuthorizeWithResponse call
func ParseProviderOauthAuthorizeResponse(rsp *http.Response) (*ProviderOauthAuthorizeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProviderOauthAuthorizeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest ProviderAuthAuthorization
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseProviderOauthCallbackResponse parses an HTTP response from a ProviderOauthCallbackWithResponse call
func ParseProviderOauthCallbackResponse(rsp *http.Response) (*ProviderOauthCallbackResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &ProviderOauthCallbackResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParsePtyListResponse parses an HTTP response from a PtyListWithResponse call
func ParsePtyListResponse(rsp *http.Response) (*PtyListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PtyListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Pty
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePtyCreateResponse parses an HTTP response from a PtyCreateWithResponse call
func ParsePtyCreateResponse(rsp *http.Response) (*PtyCreateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PtyCreateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Pty
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParsePtyRemoveResponse parses an HTTP response from a PtyRemoveWithResponse call
func ParsePtyRemoveResponse(rsp *http.Response) (*PtyRemoveResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PtyRemoveResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParsePtyGetResponse parses an HTTP response from a PtyGetWithResponse call
func ParsePtyGetResponse(rsp *http.Response) (*PtyGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PtyGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Pty
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParsePtyUpdateResponse parses an HTTP response from a PtyUpdateWithResponse call
func ParsePtyUpdateResponse(rsp *http.Response) (*PtyUpdateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PtyUpdateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Pty
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParsePtyConnectResponse parses an HTTP response from a PtyConnectWithResponse call
func ParsePtyConnectResponse(rsp *http.Response) (*PtyConnectResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PtyConnectResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseQuestionListResponse parses an HTTP response from a QuestionListWithResponse call
func ParseQuestionListResponse(rsp *http.Response) (*QuestionListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &QuestionListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []QuestionRequest
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseQuestionRejectResponse parses an HTTP response from a QuestionRejectWithResponse call
func ParseQuestionRejectResponse(rsp *http.Response) (*QuestionRejectResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &QuestionRejectResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseQuestionReplyResponse parses an HTTP response from a QuestionReplyWithResponse call
func ParseQuestionReplyResponse(rsp *http.Response) (*QuestionReplyResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &QuestionReplyResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionListResponse parses an HTTP response from a SessionListWithResponse call
func ParseSessionListResponse(rsp *http.Response) (*SessionListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseSessionCreateResponse parses an HTTP response from a SessionCreateWithResponse call
func ParseSessionCreateResponse(rsp *http.Response) (*SessionCreateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionCreateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseSessionStatusResponse parses an HTTP response from a SessionStatusWithResponse call
func ParseSessionStatusResponse(rsp *http.Response) (*SessionStatusResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest map[string]SessionStatus
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseSessionDeleteResponse parses an HTTP response from a SessionDeleteWithResponse call
func ParseSessionDeleteResponse(rsp *http.Response) (*SessionDeleteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionDeleteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionGetResponse parses an HTTP response from a SessionGetWithResponse call
func ParseSessionGetResponse(rsp *http.Response) (*SessionGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionUpdateResponse parses an HTTP response from a SessionUpdateWithResponse call
func ParseSessionUpdateResponse(rsp *http.Response) (*SessionUpdateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionUpdateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionAbortResponse parses an HTTP response from a SessionAbortWithResponse call
func ParseSessionAbortResponse(rsp *http.Response) (*SessionAbortResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionAbortResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionChildrenResponse parses an HTTP response from a SessionChildrenWithResponse call
func ParseSessionChildrenResponse(rsp *http.Response) (*SessionChildrenResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionChildrenResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionCommandResponse parses an HTTP response from a SessionCommandWithResponse call
func ParseSessionCommandResponse(rsp *http.Response) (*SessionCommandResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionCommandResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Info  AssistantMessage `json:"info"`
			Parts []Part           `json:"parts"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionDiffResponse parses an HTTP response from a SessionDiffWithResponse call
func ParseSessionDiffResponse(rsp *http.Response) (*SessionDiffResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionDiffResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []FileDiff
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionForkResponse parses an HTTP response from a SessionForkWithResponse call
func ParseSessionForkResponse(rsp *http.Response) (*SessionForkResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionForkResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseSessionInitResponse parses an HTTP response from a SessionInitWithResponse call
func ParseSessionInitResponse(rsp *http.Response) (*SessionInitResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionInitResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionMessagesResponse parses an HTTP response from a SessionMessagesWithResponse call
func ParseSessionMessagesResponse(rsp *http.Response) (*SessionMessagesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionMessagesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []struct {
			Info  Message `json:"info"`
			Parts []Part  `json:"parts"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionPromptResponse parses an HTTP response from a SessionPromptWithResponse call
func ParseSessionPromptResponse(rsp *http.Response) (*SessionPromptResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionPromptResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Info  AssistantMessage `json:"info"`
			Parts []Part           `json:"parts"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionMessageResponse parses an HTTP response from a SessionMessageWithResponse call
func ParseSessionMessageResponse(rsp *http.Response) (*SessionMessageResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionMessageResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Info  Message `json:"info"`
			Parts []Part  `json:"parts"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParsePartDeleteResponse parses an HTTP response from a PartDeleteWithResponse call
func ParsePartDeleteResponse(rsp *http.Response) (*PartDeleteResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PartDeleteResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParsePartUpdateResponse parses an HTTP response from a PartUpdateWithResponse call
func ParsePartUpdateResponse(rsp *http.Response) (*PartUpdateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PartUpdateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Part
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParsePermissionRespondResponse parses an HTTP response from a PermissionRespondWithResponse call
func ParsePermissionRespondResponse(rsp *http.Response) (*PermissionRespondResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PermissionRespondResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionPromptAsyncResponse parses an HTTP response from a SessionPromptAsyncWithResponse call
func ParseSessionPromptAsyncResponse(rsp *http.Response) (*SessionPromptAsyncResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionPromptAsyncResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionRevertResponse parses an HTTP response from a SessionRevertWithResponse call
func ParseSessionRevertResponse(rsp *http.Response) (*SessionRevertResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionRevertResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionUnshareResponse parses an HTTP response from a SessionUnshareWithResponse call
func ParseSessionUnshareResponse(rsp *http.Response) (*SessionUnshareResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionUnshareResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionShareResponse parses an HTTP response from a SessionShareWithResponse call
func ParseSessionShareResponse(rsp *http.Response) (*SessionShareResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionShareResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionShellResponse parses an HTTP response from a SessionShellWithResponse call
func ParseSessionShellResponse(rsp *http.Response) (*SessionShellResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionShellResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AssistantMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionSummarizeResponse parses an HTTP response from a SessionSummarizeWithResponse call
func ParseSessionSummarizeResponse(rsp *http.Response) (*SessionSummarizeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionSummarizeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionTodoResponse parses an HTTP response from a SessionTodoWithResponse call
func ParseSessionTodoResponse(rsp *http.Response) (*SessionTodoResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionTodoResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []Todo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseSessionUnrevertResponse parses an HTTP response from a SessionUnrevertWithResponse call
func ParseSessionUnrevertResponse(rsp *http.Response) (*SessionUnrevertResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &SessionUnrevertResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Session
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseTuiAppendPromptResponse parses an HTTP response from a TuiAppendPromptWithResponse call
func ParseTuiAppendPromptResponse(rsp *http.Response) (*TuiAppendPromptResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiAppendPromptResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseTuiClearPromptResponse parses an HTTP response from a TuiClearPromptWithResponse call
func ParseTuiClearPromptResponse(rsp *http.Response) (*TuiClearPromptResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiClearPromptResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiControlNextResponse parses an HTTP response from a TuiControlNextWithResponse call
func ParseTuiControlNextResponse(rsp *http.Response) (*TuiControlNextResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiControlNextResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Body interface{} `json:"body"`
			Path string      `json:"path"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiControlResponseResponse parses an HTTP response from a TuiControlResponseWithResponse call
func ParseTuiControlResponseResponse(rsp *http.Response) (*TuiControlResponseResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiControlResponseResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiExecuteCommandResponse parses an HTTP response from a TuiExecuteCommandWithResponse call
func ParseTuiExecuteCommandResponse(rsp *http.Response) (*TuiExecuteCommandResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiExecuteCommandResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseTuiOpenHelpResponse parses an HTTP response from a TuiOpenHelpWithResponse call
func ParseTuiOpenHelpResponse(rsp *http.Response) (*TuiOpenHelpResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiOpenHelpResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiOpenModelsResponse parses an HTTP response from a TuiOpenModelsWithResponse call
func ParseTuiOpenModelsResponse(rsp *http.Response) (*TuiOpenModelsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiOpenModelsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiOpenSessionsResponse parses an HTTP response from a TuiOpenSessionsWithResponse call
func ParseTuiOpenSessionsResponse(rsp *http.Response) (*TuiOpenSessionsResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiOpenSessionsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiOpenThemesResponse parses an HTTP response from a TuiOpenThemesWithResponse call
func ParseTuiOpenThemesResponse(rsp *http.Response) (*TuiOpenThemesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiOpenThemesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiPublishResponse parses an HTTP response from a TuiPublishWithResponse call
func ParseTuiPublishResponse(rsp *http.Response) (*TuiPublishResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiPublishResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseTuiSelectSessionResponse parses an HTTP response from a TuiSelectSessionWithResponse call
func ParseTuiSelectSessionResponse(rsp *http.Response) (*TuiSelectSessionResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiSelectSessionResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest BadRequestError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
		var dest NotFoundError
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON404 = &dest

	}

	return response, nil
}

// ParseTuiShowToastResponse parses an HTTP response from a TuiShowToastWithResponse call
func ParseTuiShowToastResponse(rsp *http.Response) (*TuiShowToastResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiShowToastResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseTuiSubmitPromptResponse parses an HTTP response from a TuiSubmitPromptWithResponse call
func ParseTuiSubmitPromptResponse(rsp *http.Response) (*TuiSubmitPromptResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &TuiSubmitPromptResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest bool
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParseVcsGetResponse parses an HTTP response from a VcsGetWithResponse call
func ParseVcsGetResponse(rsp *http.Response) (*VcsGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &VcsGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest VcsInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}