opencode-ide-plugin/packages/tui/pkg/client/generated-client.go

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

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

	"github.com/oapi-codegen/runtime"
)

// Defines values for MessageInfoRole.
const (
	Assistant MessageInfoRole = "assistant"
	System    MessageInfoRole = "system"
	User      MessageInfoRole = "user"
)

// AppInfo defines model for App.Info.
type AppInfo struct {
	Git  bool `json:"git"`
	Path struct {
		Config string `json:"config"`
		Cwd    string `json:"cwd"`
		Data   string `json:"data"`
		Root   string `json:"root"`
	} `json:"path"`
	Time struct {
		Initialized *float32 `json:"initialized,omitempty"`
	} `json:"time"`
	User string `json:"user"`
}

// Event defines model for Event.
type Event struct {
	union json.RawMessage
}

// EventLspClientDiagnostics defines model for Event.lsp.client.diagnostics.
type EventLspClientDiagnostics struct {
	Properties struct {
		Path     string `json:"path"`
		ServerID string `json:"serverID"`
	} `json:"properties"`
	Type string `json:"type"`
}

// EventMessagePartUpdated defines model for Event.message.part.updated.
type EventMessagePartUpdated struct {
	Properties struct {
		Part MessagePart `json:"part"`
	} `json:"properties"`
	Type string `json:"type"`
}

// EventMessageUpdated defines model for Event.message.updated.
type EventMessageUpdated struct {
	Properties struct {
		Info MessageInfo `json:"info"`
	} `json:"properties"`
	Type string `json:"type"`
}

// EventPermissionUpdated defines model for Event.permission.updated.
type EventPermissionUpdated struct {
	Properties PermissionInfo `json:"properties"`
	Type       string         `json:"type"`
}

// EventSessionUpdated defines model for Event.session.updated.
type EventSessionUpdated struct {
	Properties struct {
		Info SessionInfo `json:"info"`
	} `json:"properties"`
	Type string `json:"type"`
}

// EventStorageWrite defines model for Event.storage.write.
type EventStorageWrite struct {
	Properties struct {
		Content *interface{} `json:"content,omitempty"`
		Key     string       `json:"key"`
	} `json:"properties"`
	Type string `json:"type"`
}

// MessageInfo defines model for Message.Info.
type MessageInfo struct {
	Id       string `json:"id"`
	Metadata struct {
		Assistant *struct {
			Cost       float32 `json:"cost"`
			ModelID    string  `json:"modelID"`
			ProviderID string  `json:"providerID"`
			Summary    *bool   `json:"summary,omitempty"`
			Tokens     struct {
				Input     float32 `json:"input"`
				Output    float32 `json:"output"`
				Reasoning float32 `json:"reasoning"`
			} `json:"tokens"`
		} `json:"assistant,omitempty"`
		Error     *string `json:"error,omitempty"`
		SessionID string  `json:"sessionID"`
		Time      struct {
			Completed *float32 `json:"completed,omitempty"`
			Created   float32  `json:"created"`
		} `json:"time"`
		Tool map[string]interface{} `json:"tool"`
	} `json:"metadata"`
	Parts []MessagePart   `json:"parts"`
	Role  MessageInfoRole `json:"role"`
}

// MessageInfoRole defines model for MessageInfo.Role.
type MessageInfoRole string

// MessagePart defines model for Message.Part.
type MessagePart struct {
	union json.RawMessage
}

// MessagePartFile defines model for Message.Part.File.
type MessagePartFile struct {
	Filename  *string `json:"filename,omitempty"`
	MediaType string  `json:"mediaType"`
	Type      string  `json:"type"`
	Url       string  `json:"url"`
}

// MessagePartReasoning defines model for Message.Part.Reasoning.
type MessagePartReasoning struct {
	ProviderMetadata *map[string]interface{} `json:"providerMetadata,omitempty"`
	Text             string                  `json:"text"`
	Type             string                  `json:"type"`
}

// MessagePartSourceUrl defines model for Message.Part.SourceUrl.
type MessagePartSourceUrl struct {
	ProviderMetadata *map[string]interface{} `json:"providerMetadata,omitempty"`
	SourceId         string                  `json:"sourceId"`
	Title            *string                 `json:"title,omitempty"`
	Type             string                  `json:"type"`
	Url              string                  `json:"url"`
}

// MessagePartStepStart defines model for Message.Part.StepStart.
type MessagePartStepStart struct {
	Type string `json:"type"`
}

// MessagePartText defines model for Message.Part.Text.
type MessagePartText struct {
	Text string `json:"text"`
	Type string `json:"type"`
}

// MessagePartToolInvocation defines model for Message.Part.ToolInvocation.
type MessagePartToolInvocation struct {
	ToolInvocation MessageToolInvocation `json:"toolInvocation"`
	Type           string                `json:"type"`
}

// MessageToolInvocation defines model for Message.ToolInvocation.
type MessageToolInvocation struct {
	union json.RawMessage
}

// MessageToolInvocationToolCall defines model for Message.ToolInvocation.ToolCall.
type MessageToolInvocationToolCall struct {
	Args       *interface{} `json:"args,omitempty"`
	State      string       `json:"state"`
	Step       *float32     `json:"step,omitempty"`
	ToolCallId string       `json:"toolCallId"`
	ToolName   string       `json:"toolName"`
}

// MessageToolInvocationToolPartialCall defines model for Message.ToolInvocation.ToolPartialCall.
type MessageToolInvocationToolPartialCall struct {
	Args       *interface{} `json:"args,omitempty"`
	State      string       `json:"state"`
	Step       *float32     `json:"step,omitempty"`
	ToolCallId string       `json:"toolCallId"`
	ToolName   string       `json:"toolName"`
}

// MessageToolInvocationToolResult defines model for Message.ToolInvocation.ToolResult.
type MessageToolInvocationToolResult struct {
	Args       *interface{} `json:"args,omitempty"`
	Result     string       `json:"result"`
	State      string       `json:"state"`
	Step       *float32     `json:"step,omitempty"`
	ToolCallId string       `json:"toolCallId"`
	ToolName   string       `json:"toolName"`
}

// ProviderInfo defines model for Provider.Info.
type ProviderInfo struct {
	Id     string                   `json:"id"`
	Models map[string]ProviderModel `json:"models"`
	Name   string                   `json:"name"`
}

// ProviderModel defines model for Provider.Model.
type ProviderModel struct {
	Attachment bool `json:"attachment"`
	Cost       struct {
		Input        float32 `json:"input"`
		InputCached  float32 `json:"inputCached"`
		Output       float32 `json:"output"`
		OutputCached float32 `json:"outputCached"`
	} `json:"cost"`
	Id    string `json:"id"`
	Limit struct {
		Context float32 `json:"context"`
		Output  float32 `json:"output"`
	} `json:"limit"`
	Name      *string `json:"name,omitempty"`
	Reasoning *bool   `json:"reasoning,omitempty"`
}

// PermissionInfo defines model for permission.info.
type PermissionInfo struct {
	Id        string                 `json:"id"`
	Metadata  map[string]interface{} `json:"metadata"`
	SessionID string                 `json:"sessionID"`
	Time      struct {
		Created float32 `json:"created"`
	} `json:"time"`
	Title string `json:"title"`
}

// SessionInfo defines model for session.info.
type SessionInfo struct {
	Id    string `json:"id"`
	Share *struct {
		Secret string `json:"secret"`
		Url    string `json:"url"`
	} `json:"share,omitempty"`
	Time struct {
		Created float32 `json:"created"`
		Updated float32 `json:"updated"`
	} `json:"time"`
	Title string `json:"title"`
}

// PostSessionAbortJSONBody defines parameters for PostSessionAbort.
type PostSessionAbortJSONBody struct {
	SessionID string `json:"sessionID"`
}

// PostSessionChatJSONBody defines parameters for PostSessionChat.
type PostSessionChatJSONBody struct {
	ModelID    string        `json:"modelID"`
	Parts      []MessagePart `json:"parts"`
	ProviderID string        `json:"providerID"`
	SessionID  string        `json:"sessionID"`
}

// PostSessionInitializeJSONBody defines parameters for PostSessionInitialize.
type PostSessionInitializeJSONBody struct {
	ModelID    string `json:"modelID"`
	ProviderID string `json:"providerID"`
	SessionID  string `json:"sessionID"`
}

// PostSessionMessagesJSONBody defines parameters for PostSessionMessages.
type PostSessionMessagesJSONBody struct {
	SessionID string `json:"sessionID"`
}

// PostSessionShareJSONBody defines parameters for PostSessionShare.
type PostSessionShareJSONBody struct {
	SessionID string `json:"sessionID"`
}

// PostSessionSummarizeJSONBody defines parameters for PostSessionSummarize.
type PostSessionSummarizeJSONBody struct {
	ModelID    string `json:"modelID"`
	ProviderID string `json:"providerID"`
	SessionID  string `json:"sessionID"`
}

// PostSessionAbortJSONRequestBody defines body for PostSessionAbort for application/json ContentType.
type PostSessionAbortJSONRequestBody PostSessionAbortJSONBody

// PostSessionChatJSONRequestBody defines body for PostSessionChat for application/json ContentType.
type PostSessionChatJSONRequestBody PostSessionChatJSONBody

// PostSessionInitializeJSONRequestBody defines body for PostSessionInitialize for application/json ContentType.
type PostSessionInitializeJSONRequestBody PostSessionInitializeJSONBody

// PostSessionMessagesJSONRequestBody defines body for PostSessionMessages for application/json ContentType.
type PostSessionMessagesJSONRequestBody PostSessionMessagesJSONBody

// PostSessionShareJSONRequestBody defines body for PostSessionShare for application/json ContentType.
type PostSessionShareJSONRequestBody PostSessionShareJSONBody

// PostSessionSummarizeJSONRequestBody defines body for PostSessionSummarize for application/json ContentType.
type PostSessionSummarizeJSONRequestBody PostSessionSummarizeJSONBody

// AsEventStorageWrite returns the union data inside the Event as a EventStorageWrite
func (t Event) AsEventStorageWrite() (EventStorageWrite, error) {
	var body EventStorageWrite
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEventStorageWrite overwrites any union data inside the Event as the provided EventStorageWrite
func (t *Event) FromEventStorageWrite(v EventStorageWrite) error {
	v.Type = "storage.write"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEventStorageWrite performs a merge with any union data inside the Event, using the provided EventStorageWrite
func (t *Event) MergeEventStorageWrite(v EventStorageWrite) error {
	v.Type = "storage.write"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEventMessageUpdated returns the union data inside the Event as a EventMessageUpdated
func (t Event) AsEventMessageUpdated() (EventMessageUpdated, error) {
	var body EventMessageUpdated
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEventMessageUpdated overwrites any union data inside the Event as the provided EventMessageUpdated
func (t *Event) FromEventMessageUpdated(v EventMessageUpdated) error {
	v.Type = "message.updated"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEventMessageUpdated performs a merge with any union data inside the Event, using the provided EventMessageUpdated
func (t *Event) MergeEventMessageUpdated(v EventMessageUpdated) error {
	v.Type = "message.updated"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEventMessagePartUpdated returns the union data inside the Event as a EventMessagePartUpdated
func (t Event) AsEventMessagePartUpdated() (EventMessagePartUpdated, error) {
	var body EventMessagePartUpdated
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEventMessagePartUpdated overwrites any union data inside the Event as the provided EventMessagePartUpdated
func (t *Event) FromEventMessagePartUpdated(v EventMessagePartUpdated) error {
	v.Type = "message.part.updated"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEventMessagePartUpdated performs a merge with any union data inside the Event, using the provided EventMessagePartUpdated
func (t *Event) MergeEventMessagePartUpdated(v EventMessagePartUpdated) error {
	v.Type = "message.part.updated"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEventLspClientDiagnostics returns the union data inside the Event as a EventLspClientDiagnostics
func (t Event) AsEventLspClientDiagnostics() (EventLspClientDiagnostics, error) {
	var body EventLspClientDiagnostics
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEventLspClientDiagnostics overwrites any union data inside the Event as the provided EventLspClientDiagnostics
func (t *Event) FromEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
	v.Type = "lsp.client.diagnostics"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEventLspClientDiagnostics performs a merge with any union data inside the Event, using the provided EventLspClientDiagnostics
func (t *Event) MergeEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
	v.Type = "lsp.client.diagnostics"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEventPermissionUpdated returns the union data inside the Event as a EventPermissionUpdated
func (t Event) AsEventPermissionUpdated() (EventPermissionUpdated, error) {
	var body EventPermissionUpdated
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEventPermissionUpdated overwrites any union data inside the Event as the provided EventPermissionUpdated
func (t *Event) FromEventPermissionUpdated(v EventPermissionUpdated) error {
	v.Type = "permission.updated"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEventPermissionUpdated performs a merge with any union data inside the Event, using the provided EventPermissionUpdated
func (t *Event) MergeEventPermissionUpdated(v EventPermissionUpdated) error {
	v.Type = "permission.updated"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsEventSessionUpdated returns the union data inside the Event as a EventSessionUpdated
func (t Event) AsEventSessionUpdated() (EventSessionUpdated, error) {
	var body EventSessionUpdated
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromEventSessionUpdated overwrites any union data inside the Event as the provided EventSessionUpdated
func (t *Event) FromEventSessionUpdated(v EventSessionUpdated) error {
	v.Type = "session.updated"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeEventSessionUpdated performs a merge with any union data inside the Event, using the provided EventSessionUpdated
func (t *Event) MergeEventSessionUpdated(v EventSessionUpdated) error {
	v.Type = "session.updated"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t Event) Discriminator() (string, error) {
	var discriminator struct {
		Discriminator string `json:"type"`
	}
	err := json.Unmarshal(t.union, &discriminator)
	return discriminator.Discriminator, err
}

func (t Event) ValueByDiscriminator() (interface{}, error) {
	discriminator, err := t.Discriminator()
	if err != nil {
		return nil, err
	}
	switch discriminator {
	case "lsp.client.diagnostics":
		return t.AsEventLspClientDiagnostics()
	case "message.part.updated":
		return t.AsEventMessagePartUpdated()
	case "message.updated":
		return t.AsEventMessageUpdated()
	case "permission.updated":
		return t.AsEventPermissionUpdated()
	case "session.updated":
		return t.AsEventSessionUpdated()
	case "storage.write":
		return t.AsEventStorageWrite()
	default:
		return nil, errors.New("unknown discriminator value: " + discriminator)
	}
}

func (t Event) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *Event) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsMessagePartText returns the union data inside the MessagePart as a MessagePartText
func (t MessagePart) AsMessagePartText() (MessagePartText, error) {
	var body MessagePartText
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessagePartText overwrites any union data inside the MessagePart as the provided MessagePartText
func (t *MessagePart) FromMessagePartText(v MessagePartText) error {
	v.Type = "text"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessagePartText performs a merge with any union data inside the MessagePart, using the provided MessagePartText
func (t *MessagePart) MergeMessagePartText(v MessagePartText) error {
	v.Type = "text"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessagePartReasoning returns the union data inside the MessagePart as a MessagePartReasoning
func (t MessagePart) AsMessagePartReasoning() (MessagePartReasoning, error) {
	var body MessagePartReasoning
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessagePartReasoning overwrites any union data inside the MessagePart as the provided MessagePartReasoning
func (t *MessagePart) FromMessagePartReasoning(v MessagePartReasoning) error {
	v.Type = "reasoning"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessagePartReasoning performs a merge with any union data inside the MessagePart, using the provided MessagePartReasoning
func (t *MessagePart) MergeMessagePartReasoning(v MessagePartReasoning) error {
	v.Type = "reasoning"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessagePartToolInvocation returns the union data inside the MessagePart as a MessagePartToolInvocation
func (t MessagePart) AsMessagePartToolInvocation() (MessagePartToolInvocation, error) {
	var body MessagePartToolInvocation
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessagePartToolInvocation overwrites any union data inside the MessagePart as the provided MessagePartToolInvocation
func (t *MessagePart) FromMessagePartToolInvocation(v MessagePartToolInvocation) error {
	v.Type = "tool-invocation"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessagePartToolInvocation performs a merge with any union data inside the MessagePart, using the provided MessagePartToolInvocation
func (t *MessagePart) MergeMessagePartToolInvocation(v MessagePartToolInvocation) error {
	v.Type = "tool-invocation"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessagePartSourceUrl returns the union data inside the MessagePart as a MessagePartSourceUrl
func (t MessagePart) AsMessagePartSourceUrl() (MessagePartSourceUrl, error) {
	var body MessagePartSourceUrl
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessagePartSourceUrl overwrites any union data inside the MessagePart as the provided MessagePartSourceUrl
func (t *MessagePart) FromMessagePartSourceUrl(v MessagePartSourceUrl) error {
	v.Type = "source-url"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessagePartSourceUrl performs a merge with any union data inside the MessagePart, using the provided MessagePartSourceUrl
func (t *MessagePart) MergeMessagePartSourceUrl(v MessagePartSourceUrl) error {
	v.Type = "source-url"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessagePartFile returns the union data inside the MessagePart as a MessagePartFile
func (t MessagePart) AsMessagePartFile() (MessagePartFile, error) {
	var body MessagePartFile
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessagePartFile overwrites any union data inside the MessagePart as the provided MessagePartFile
func (t *MessagePart) FromMessagePartFile(v MessagePartFile) error {
	v.Type = "file"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessagePartFile performs a merge with any union data inside the MessagePart, using the provided MessagePartFile
func (t *MessagePart) MergeMessagePartFile(v MessagePartFile) error {
	v.Type = "file"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessagePartStepStart returns the union data inside the MessagePart as a MessagePartStepStart
func (t MessagePart) AsMessagePartStepStart() (MessagePartStepStart, error) {
	var body MessagePartStepStart
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessagePartStepStart overwrites any union data inside the MessagePart as the provided MessagePartStepStart
func (t *MessagePart) FromMessagePartStepStart(v MessagePartStepStart) error {
	v.Type = "step-start"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessagePartStepStart performs a merge with any union data inside the MessagePart, using the provided MessagePartStepStart
func (t *MessagePart) MergeMessagePartStepStart(v MessagePartStepStart) error {
	v.Type = "step-start"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t MessagePart) Discriminator() (string, error) {
	var discriminator struct {
		Discriminator string `json:"type"`
	}
	err := json.Unmarshal(t.union, &discriminator)
	return discriminator.Discriminator, err
}

func (t MessagePart) ValueByDiscriminator() (interface{}, error) {
	discriminator, err := t.Discriminator()
	if err != nil {
		return nil, err
	}
	switch discriminator {
	case "file":
		return t.AsMessagePartFile()
	case "reasoning":
		return t.AsMessagePartReasoning()
	case "source-url":
		return t.AsMessagePartSourceUrl()
	case "step-start":
		return t.AsMessagePartStepStart()
	case "text":
		return t.AsMessagePartText()
	case "tool-invocation":
		return t.AsMessagePartToolInvocation()
	default:
		return nil, errors.New("unknown discriminator value: " + discriminator)
	}
}

func (t MessagePart) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *MessagePart) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsMessageToolInvocationToolCall returns the union data inside the MessageToolInvocation as a MessageToolInvocationToolCall
func (t MessageToolInvocation) AsMessageToolInvocationToolCall() (MessageToolInvocationToolCall, error) {
	var body MessageToolInvocationToolCall
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessageToolInvocationToolCall overwrites any union data inside the MessageToolInvocation as the provided MessageToolInvocationToolCall
func (t *MessageToolInvocation) FromMessageToolInvocationToolCall(v MessageToolInvocationToolCall) error {
	v.State = "call"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessageToolInvocationToolCall performs a merge with any union data inside the MessageToolInvocation, using the provided MessageToolInvocationToolCall
func (t *MessageToolInvocation) MergeMessageToolInvocationToolCall(v MessageToolInvocationToolCall) error {
	v.State = "call"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessageToolInvocationToolPartialCall returns the union data inside the MessageToolInvocation as a MessageToolInvocationToolPartialCall
func (t MessageToolInvocation) AsMessageToolInvocationToolPartialCall() (MessageToolInvocationToolPartialCall, error) {
	var body MessageToolInvocationToolPartialCall
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessageToolInvocationToolPartialCall overwrites any union data inside the MessageToolInvocation as the provided MessageToolInvocationToolPartialCall
func (t *MessageToolInvocation) FromMessageToolInvocationToolPartialCall(v MessageToolInvocationToolPartialCall) error {
	v.State = "partial-call"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessageToolInvocationToolPartialCall performs a merge with any union data inside the MessageToolInvocation, using the provided MessageToolInvocationToolPartialCall
func (t *MessageToolInvocation) MergeMessageToolInvocationToolPartialCall(v MessageToolInvocationToolPartialCall) error {
	v.State = "partial-call"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsMessageToolInvocationToolResult returns the union data inside the MessageToolInvocation as a MessageToolInvocationToolResult
func (t MessageToolInvocation) AsMessageToolInvocationToolResult() (MessageToolInvocationToolResult, error) {
	var body MessageToolInvocationToolResult
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromMessageToolInvocationToolResult overwrites any union data inside the MessageToolInvocation as the provided MessageToolInvocationToolResult
func (t *MessageToolInvocation) FromMessageToolInvocationToolResult(v MessageToolInvocationToolResult) error {
	v.State = "result"
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeMessageToolInvocationToolResult performs a merge with any union data inside the MessageToolInvocation, using the provided MessageToolInvocationToolResult
func (t *MessageToolInvocation) MergeMessageToolInvocationToolResult(v MessageToolInvocationToolResult) error {
	v.State = "result"
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t MessageToolInvocation) Discriminator() (string, error) {
	var discriminator struct {
		Discriminator string `json:"state"`
	}
	err := json.Unmarshal(t.union, &discriminator)
	return discriminator.Discriminator, err
}

func (t MessageToolInvocation) ValueByDiscriminator() (interface{}, error) {
	discriminator, err := t.Discriminator()
	if err != nil {
		return nil, err
	}
	switch discriminator {
	case "call":
		return t.AsMessageToolInvocationToolCall()
	case "partial-call":
		return t.AsMessageToolInvocationToolPartialCall()
	case "result":
		return t.AsMessageToolInvocationToolResult()
	default:
		return nil, errors.New("unknown discriminator value: " + discriminator)
	}
}

func (t MessageToolInvocation) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *MessageToolInvocation) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// 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 {
	// PostAppInfo request
	PostAppInfo(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

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

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

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

	PostSessionAbort(ctx context.Context, body PostSessionAbortJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostSessionChat(ctx context.Context, body PostSessionChatJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	PostSessionInitialize(ctx context.Context, body PostSessionInitializeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

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

	PostSessionMessages(ctx context.Context, body PostSessionMessagesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostSessionShare(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

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

	PostSessionSummarize(ctx context.Context, body PostSessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) PostAppInfo(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostAppInfoRequest(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) PostAppInitialize(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostAppInitializeRequest(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) GetEvent(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetEventRequest(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) PostPathGet(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostPathGetRequest(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) PostProviderList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostProviderListRequest(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) PostSessionAbortWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionAbortRequestWithBody(c.Server, 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) PostSessionAbort(ctx context.Context, body PostSessionAbortJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionAbortRequest(c.Server, 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) PostSessionChatWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionChatRequestWithBody(c.Server, 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) PostSessionChat(ctx context.Context, body PostSessionChatJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionChatRequest(c.Server, 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) PostSessionCreate(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionCreateRequest(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) PostSessionInitializeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionInitializeRequestWithBody(c.Server, 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) PostSessionInitialize(ctx context.Context, body PostSessionInitializeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionInitializeRequest(c.Server, 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) PostSessionList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionListRequest(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) PostSessionMessagesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionMessagesRequestWithBody(c.Server, 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) PostSessionMessages(ctx context.Context, body PostSessionMessagesJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionMessagesRequest(c.Server, 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) PostSessionShareWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionShareRequestWithBody(c.Server, 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) PostSessionShare(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionShareRequest(c.Server, 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) PostSessionSummarizeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionSummarizeRequestWithBody(c.Server, 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) PostSessionSummarize(ctx context.Context, body PostSessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewPostSessionSummarizeRequest(c.Server, 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)
}

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

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

	operationPath := fmt.Sprintf("/app_info")
	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
}

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

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

	operationPath := fmt.Sprintf("/app_initialize")
	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
}

// NewGetEventRequest generates requests for GetEvent
func NewGetEventRequest(server string) (*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
	}

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/path_get")
	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
}

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

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

	operationPath := fmt.Sprintf("/provider_list")
	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
}

// NewPostSessionAbortRequest calls the generic PostSessionAbort builder with application/json body
func NewPostSessionAbortRequest(server string, body PostSessionAbortJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostSessionAbortRequestWithBody(server, "application/json", bodyReader)
}

// NewPostSessionAbortRequestWithBody generates requests for PostSessionAbort with any type of body
func NewPostSessionAbortRequestWithBody(server string, 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_abort")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

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

	return req, nil
}

// NewPostSessionChatRequest calls the generic PostSessionChat builder with application/json body
func NewPostSessionChatRequest(server string, body PostSessionChatJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostSessionChatRequestWithBody(server, "application/json", bodyReader)
}

// NewPostSessionChatRequestWithBody generates requests for PostSessionChat with any type of body
func NewPostSessionChatRequestWithBody(server string, 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_chat")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/session_create")
	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
}

// NewPostSessionInitializeRequest calls the generic PostSessionInitialize builder with application/json body
func NewPostSessionInitializeRequest(server string, body PostSessionInitializeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostSessionInitializeRequestWithBody(server, "application/json", bodyReader)
}

// NewPostSessionInitializeRequestWithBody generates requests for PostSessionInitialize with any type of body
func NewPostSessionInitializeRequestWithBody(server string, 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_initialize")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

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

	return req, nil
}

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

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

	operationPath := fmt.Sprintf("/session_list")
	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
}

// NewPostSessionMessagesRequest calls the generic PostSessionMessages builder with application/json body
func NewPostSessionMessagesRequest(server string, body PostSessionMessagesJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostSessionMessagesRequestWithBody(server, "application/json", bodyReader)
}

// NewPostSessionMessagesRequestWithBody generates requests for PostSessionMessages with any type of body
func NewPostSessionMessagesRequestWithBody(server string, 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_messages")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

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

	return req, nil
}

// NewPostSessionShareRequest calls the generic PostSessionShare builder with application/json body
func NewPostSessionShareRequest(server string, body PostSessionShareJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostSessionShareRequestWithBody(server, "application/json", bodyReader)
}

// NewPostSessionShareRequestWithBody generates requests for PostSessionShare with any type of body
func NewPostSessionShareRequestWithBody(server string, 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_share")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

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

	return req, nil
}

// NewPostSessionSummarizeRequest calls the generic PostSessionSummarize builder with application/json body
func NewPostSessionSummarizeRequest(server string, body PostSessionSummarizeJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewPostSessionSummarizeRequestWithBody(server, "application/json", bodyReader)
}

// NewPostSessionSummarizeRequestWithBody generates requests for PostSessionSummarize with any type of body
func NewPostSessionSummarizeRequestWithBody(server string, 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_summarize")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

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

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

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

	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 {
	// PostAppInfoWithResponse request
	PostAppInfoWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostAppInfoResponse, error)

	// PostAppInitializeWithResponse request
	PostAppInitializeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostAppInitializeResponse, error)

	// GetEventWithResponse request
	GetEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetEventResponse, error)

	// PostPathGetWithResponse request
	PostPathGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostPathGetResponse, error)

	// PostProviderListWithResponse request
	PostProviderListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostProviderListResponse, error)

	// PostSessionAbortWithBodyWithResponse request with any body
	PostSessionAbortWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionAbortResponse, error)

	PostSessionAbortWithResponse(ctx context.Context, body PostSessionAbortJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionAbortResponse, error)

	// PostSessionChatWithBodyWithResponse request with any body
	PostSessionChatWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionChatResponse, error)

	PostSessionChatWithResponse(ctx context.Context, body PostSessionChatJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionChatResponse, error)

	// PostSessionCreateWithResponse request
	PostSessionCreateWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostSessionCreateResponse, error)

	// PostSessionInitializeWithBodyWithResponse request with any body
	PostSessionInitializeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionInitializeResponse, error)

	PostSessionInitializeWithResponse(ctx context.Context, body PostSessionInitializeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionInitializeResponse, error)

	// PostSessionListWithResponse request
	PostSessionListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostSessionListResponse, error)

	// PostSessionMessagesWithBodyWithResponse request with any body
	PostSessionMessagesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionMessagesResponse, error)

	PostSessionMessagesWithResponse(ctx context.Context, body PostSessionMessagesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionMessagesResponse, error)

	// PostSessionShareWithBodyWithResponse request with any body
	PostSessionShareWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionShareResponse, error)

	PostSessionShareWithResponse(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionShareResponse, error)

	// PostSessionSummarizeWithBodyWithResponse request with any body
	PostSessionSummarizeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionSummarizeResponse, error)

	PostSessionSummarizeWithResponse(ctx context.Context, body PostSessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionSummarizeResponse, error)
}

type PostAppInfoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *AppInfo
}

// Status returns HTTPResponse.Status
func (r PostAppInfoResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostAppInfoResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostAppInitializeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r PostAppInitializeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostAppInitializeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetEventResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Event
}

// Status returns HTTPResponse.Status
func (r GetEventResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetEventResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostPathGetResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Config string `json:"config"`
		Cwd    string `json:"cwd"`
		Data   string `json:"data"`
		Root   string `json:"root"`
	}
}

// Status returns HTTPResponse.Status
func (r PostPathGetResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostPathGetResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostProviderListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *struct {
		Default   map[string]string `json:"default"`
		Providers []ProviderInfo    `json:"providers"`
	}
}

// Status returns HTTPResponse.Status
func (r PostProviderListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostProviderListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionAbortResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r PostSessionAbortResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionAbortResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionChatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *MessageInfo
}

// Status returns HTTPResponse.Status
func (r PostSessionChatResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionChatResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionCreateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SessionInfo
}

// Status returns HTTPResponse.Status
func (r PostSessionCreateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionCreateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionInitializeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r PostSessionInitializeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionInitializeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]SessionInfo
}

// Status returns HTTPResponse.Status
func (r PostSessionListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionMessagesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *[]MessageInfo
}

// Status returns HTTPResponse.Status
func (r PostSessionMessagesResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionMessagesResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionShareResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SessionInfo
}

// Status returns HTTPResponse.Status
func (r PostSessionShareResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionShareResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type PostSessionSummarizeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *bool
}

// Status returns HTTPResponse.Status
func (r PostSessionSummarizeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r PostSessionSummarizeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// PostAppInfoWithResponse request returning *PostAppInfoResponse
func (c *ClientWithResponses) PostAppInfoWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostAppInfoResponse, error) {
	rsp, err := c.PostAppInfo(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostAppInfoResponse(rsp)
}

// PostAppInitializeWithResponse request returning *PostAppInitializeResponse
func (c *ClientWithResponses) PostAppInitializeWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostAppInitializeResponse, error) {
	rsp, err := c.PostAppInitialize(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostAppInitializeResponse(rsp)
}

// GetEventWithResponse request returning *GetEventResponse
func (c *ClientWithResponses) GetEventWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetEventResponse, error) {
	rsp, err := c.GetEvent(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetEventResponse(rsp)
}

// PostPathGetWithResponse request returning *PostPathGetResponse
func (c *ClientWithResponses) PostPathGetWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostPathGetResponse, error) {
	rsp, err := c.PostPathGet(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostPathGetResponse(rsp)
}

// PostProviderListWithResponse request returning *PostProviderListResponse
func (c *ClientWithResponses) PostProviderListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostProviderListResponse, error) {
	rsp, err := c.PostProviderList(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostProviderListResponse(rsp)
}

// PostSessionAbortWithBodyWithResponse request with arbitrary body returning *PostSessionAbortResponse
func (c *ClientWithResponses) PostSessionAbortWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionAbortResponse, error) {
	rsp, err := c.PostSessionAbortWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionAbortResponse(rsp)
}

func (c *ClientWithResponses) PostSessionAbortWithResponse(ctx context.Context, body PostSessionAbortJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionAbortResponse, error) {
	rsp, err := c.PostSessionAbort(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionAbortResponse(rsp)
}

// PostSessionChatWithBodyWithResponse request with arbitrary body returning *PostSessionChatResponse
func (c *ClientWithResponses) PostSessionChatWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionChatResponse, error) {
	rsp, err := c.PostSessionChatWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionChatResponse(rsp)
}

func (c *ClientWithResponses) PostSessionChatWithResponse(ctx context.Context, body PostSessionChatJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionChatResponse, error) {
	rsp, err := c.PostSessionChat(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionChatResponse(rsp)
}

// PostSessionCreateWithResponse request returning *PostSessionCreateResponse
func (c *ClientWithResponses) PostSessionCreateWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostSessionCreateResponse, error) {
	rsp, err := c.PostSessionCreate(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionCreateResponse(rsp)
}

// PostSessionInitializeWithBodyWithResponse request with arbitrary body returning *PostSessionInitializeResponse
func (c *ClientWithResponses) PostSessionInitializeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionInitializeResponse, error) {
	rsp, err := c.PostSessionInitializeWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionInitializeResponse(rsp)
}

func (c *ClientWithResponses) PostSessionInitializeWithResponse(ctx context.Context, body PostSessionInitializeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionInitializeResponse, error) {
	rsp, err := c.PostSessionInitialize(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionInitializeResponse(rsp)
}

// PostSessionListWithResponse request returning *PostSessionListResponse
func (c *ClientWithResponses) PostSessionListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*PostSessionListResponse, error) {
	rsp, err := c.PostSessionList(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionListResponse(rsp)
}

// PostSessionMessagesWithBodyWithResponse request with arbitrary body returning *PostSessionMessagesResponse
func (c *ClientWithResponses) PostSessionMessagesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionMessagesResponse, error) {
	rsp, err := c.PostSessionMessagesWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionMessagesResponse(rsp)
}

func (c *ClientWithResponses) PostSessionMessagesWithResponse(ctx context.Context, body PostSessionMessagesJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionMessagesResponse, error) {
	rsp, err := c.PostSessionMessages(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionMessagesResponse(rsp)
}

// PostSessionShareWithBodyWithResponse request with arbitrary body returning *PostSessionShareResponse
func (c *ClientWithResponses) PostSessionShareWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionShareResponse, error) {
	rsp, err := c.PostSessionShareWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionShareResponse(rsp)
}

func (c *ClientWithResponses) PostSessionShareWithResponse(ctx context.Context, body PostSessionShareJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionShareResponse, error) {
	rsp, err := c.PostSessionShare(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionShareResponse(rsp)
}

// PostSessionSummarizeWithBodyWithResponse request with arbitrary body returning *PostSessionSummarizeResponse
func (c *ClientWithResponses) PostSessionSummarizeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostSessionSummarizeResponse, error) {
	rsp, err := c.PostSessionSummarizeWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionSummarizeResponse(rsp)
}

func (c *ClientWithResponses) PostSessionSummarizeWithResponse(ctx context.Context, body PostSessionSummarizeJSONRequestBody, reqEditors ...RequestEditorFn) (*PostSessionSummarizeResponse, error) {
	rsp, err := c.PostSessionSummarize(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParsePostSessionSummarizeResponse(rsp)
}

// ParsePostAppInfoResponse parses an HTTP response from a PostAppInfoWithResponse call
func ParsePostAppInfoResponse(rsp *http.Response) (*PostAppInfoResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostAppInfoResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest AppInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostAppInitializeResponse parses an HTTP response from a PostAppInitializeWithResponse call
func ParsePostAppInitializeResponse(rsp *http.Response) (*PostAppInitializeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostAppInitializeResponse{
		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
}

// ParseGetEventResponse parses an HTTP response from a GetEventWithResponse call
func ParseGetEventResponse(rsp *http.Response) (*GetEventResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetEventResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Event
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostPathGetResponse parses an HTTP response from a PostPathGetWithResponse call
func ParsePostPathGetResponse(rsp *http.Response) (*PostPathGetResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostPathGetResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest struct {
			Config string `json:"config"`
			Cwd    string `json:"cwd"`
			Data   string `json:"data"`
			Root   string `json:"root"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostProviderListResponse parses an HTTP response from a PostProviderListWithResponse call
func ParsePostProviderListResponse(rsp *http.Response) (*PostProviderListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostProviderListResponse{
		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 []ProviderInfo    `json:"providers"`
		}
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostSessionAbortResponse parses an HTTP response from a PostSessionAbortWithResponse call
func ParsePostSessionAbortResponse(rsp *http.Response) (*PostSessionAbortResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionAbortResponse{
		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
}

// ParsePostSessionChatResponse parses an HTTP response from a PostSessionChatWithResponse call
func ParsePostSessionChatResponse(rsp *http.Response) (*PostSessionChatResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionChatResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest MessageInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostSessionCreateResponse parses an HTTP response from a PostSessionCreateWithResponse call
func ParsePostSessionCreateResponse(rsp *http.Response) (*PostSessionCreateResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionCreateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SessionInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostSessionInitializeResponse parses an HTTP response from a PostSessionInitializeWithResponse call
func ParsePostSessionInitializeResponse(rsp *http.Response) (*PostSessionInitializeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionInitializeResponse{
		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
}

// ParsePostSessionListResponse parses an HTTP response from a PostSessionListWithResponse call
func ParsePostSessionListResponse(rsp *http.Response) (*PostSessionListResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []SessionInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostSessionMessagesResponse parses an HTTP response from a PostSessionMessagesWithResponse call
func ParsePostSessionMessagesResponse(rsp *http.Response) (*PostSessionMessagesResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionMessagesResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest []MessageInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostSessionShareResponse parses an HTTP response from a PostSessionShareWithResponse call
func ParsePostSessionShareResponse(rsp *http.Response) (*PostSessionShareResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionShareResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SessionInfo
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	}

	return response, nil
}

// ParsePostSessionSummarizeResponse parses an HTTP response from a PostSessionSummarizeWithResponse call
func ParsePostSessionSummarizeResponse(rsp *http.Response) (*PostSessionSummarizeResponse, error) {
	bodyBytes, err := io.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &PostSessionSummarizeResponse{
		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
}