summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorDax Raad <[email protected]>2025-06-02 22:14:12 -0400
committerDax Raad <[email protected]>2025-06-02 22:14:12 -0400
commit8487346d3f48b542c7afcb34812e57cb381c02c4 (patch)
tree439388eb4958f7764c7760b14bdc5e3f4a276f19
parent54b99cd88a56095422c88003c7814ddfef513c87 (diff)
downloadopencode-8487346d3f48b542c7afcb34812e57cb381c02c4.tar.gz
opencode-8487346d3f48b542c7afcb34812e57cb381c02c4.zip
check in generated files
Diffstat
-rw-r--r--packages/tui/pkg/client/.gitignore2
-rw-r--r--packages/tui/pkg/client/gen/openapi.json993
-rw-r--r--packages/tui/pkg/client/generated-client.go2112
3 files changed, 3105 insertions, 2 deletions
diff --git a/packages/tui/pkg/client/.gitignore b/packages/tui/pkg/client/.gitignore
index c56971e89..e69de29bb 100644
--- a/packages/tui/pkg/client/.gitignore
+++ b/packages/tui/pkg/client/.gitignore
@@ -1,2 +0,0 @@
-gen
-generated-*.go
diff --git a/packages/tui/pkg/client/gen/openapi.json b/packages/tui/pkg/client/gen/openapi.json
new file mode 100644
index 000000000..0f9949dad
--- /dev/null
+++ b/packages/tui/pkg/client/gen/openapi.json
@@ -0,0 +1,993 @@
+{
+ "openapi": "3.0.0",
+ "info": {
+ "title": "opencode",
+ "description": "opencode api",
+ "version": "1.0.0"
+ },
+ "paths": {
+ "/event": {
+ "get": {
+ "responses": {
+ "200": {
+ "description": "Event stream",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Event"
+ }
+ }
+ }
+ }
+ },
+ "operationId": "getEvent",
+ "parameters": [],
+ "description": "Get events"
+ }
+ },
+ "/path_get": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "200",
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "object",
+ "properties": {
+ "root": {
+ "type": "string"
+ },
+ "data": {
+ "type": "string"
+ },
+ "cwd": {
+ "type": "string"
+ },
+ "config": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "root",
+ "data",
+ "cwd",
+ "config"
+ ]
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postPath_get",
+ "parameters": [],
+ "description": "Get paths"
+ }
+ },
+ "/session_create": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "Successfully created session",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/session.info"
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_create",
+ "parameters": [],
+ "description": "Create a new session"
+ }
+ },
+ "/session_share": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "Successfully shared session",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/session.info"
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_share",
+ "parameters": [],
+ "description": "Share the session",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "object",
+ "properties": {
+ "sessionID": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionID"
+ ]
+ }
+ }
+ }
+ }
+ }
+ },
+ "/session_messages": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "Successfully created session",
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/Message.Info"
+ }
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_messages",
+ "parameters": [],
+ "description": "Get messages for a session",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "object",
+ "properties": {
+ "sessionID": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionID"
+ ]
+ }
+ }
+ }
+ }
+ }
+ },
+ "/session_list": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "List of sessions",
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/session.info"
+ }
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_list",
+ "parameters": [],
+ "description": "List all sessions"
+ }
+ },
+ "/session_abort": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "Aborted session",
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "boolean"
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_abort",
+ "parameters": [],
+ "description": "Abort a session",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "object",
+ "properties": {
+ "sessionID": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionID"
+ ]
+ }
+ }
+ }
+ }
+ }
+ },
+ "/session_summarize": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "Summarize the session",
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "boolean"
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_summarize",
+ "parameters": [],
+ "description": "Summarize the session",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "object",
+ "properties": {
+ "sessionID": {
+ "type": "string"
+ },
+ "providerID": {
+ "type": "string"
+ },
+ "modelID": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "sessionID",
+ "providerID",
+ "modelID"
+ ]
+ }
+ }
+ }
+ }
+ }
+ },
+ "/session_chat": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "Chat with a model",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Message.Info"
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postSession_chat",
+ "parameters": [],
+ "description": "Chat with a model",
+ "requestBody": {
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "object",
+ "properties": {
+ "sessionID": {
+ "type": "string"
+ },
+ "providerID": {
+ "type": "string"
+ },
+ "modelID": {
+ "type": "string"
+ },
+ "parts": {
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/Message.Part"
+ }
+ }
+ },
+ "required": [
+ "sessionID",
+ "providerID",
+ "modelID",
+ "parts"
+ ]
+ }
+ }
+ }
+ }
+ }
+ },
+ "/provider_list": {
+ "post": {
+ "responses": {
+ "200": {
+ "description": "List of providers",
+ "content": {
+ "application/json": {
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/Provider.Info"
+ }
+ }
+ }
+ }
+ }
+ },
+ "operationId": "postProvider_list",
+ "parameters": [],
+ "description": "List all providers"
+ }
+ }
+ },
+ "components": {
+ "schemas": {
+ "Event": {
+ "oneOf": [
+ {
+ "$ref": "#/components/schemas/Event.storage.write"
+ },
+ {
+ "$ref": "#/components/schemas/Event.message.updated"
+ },
+ {
+ "$ref": "#/components/schemas/Event.lsp.client.diagnostics"
+ },
+ {
+ "$ref": "#/components/schemas/Event.permission.updated"
+ },
+ {
+ "$ref": "#/components/schemas/Event.session.updated"
+ }
+ ],
+ "discriminator": {
+ "propertyName": "type",
+ "mapping": {
+ "storage.write": "#/components/schemas/Event.storage.write",
+ "message.updated": "#/components/schemas/Event.message.updated",
+ "lsp.client.diagnostics": "#/components/schemas/Event.lsp.client.diagnostics",
+ "permission.updated": "#/components/schemas/Event.permission.updated",
+ "session.updated": "#/components/schemas/Event.session.updated"
+ }
+ }
+ },
+ "Event.storage.write": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "storage.write"
+ },
+ "properties": {
+ "type": "object",
+ "properties": {
+ "key": {
+ "type": "string"
+ },
+ "content": {}
+ },
+ "required": [
+ "key"
+ ]
+ }
+ },
+ "required": [
+ "type",
+ "properties"
+ ]
+ },
+ "Event.message.updated": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "message.updated"
+ },
+ "properties": {
+ "type": "object",
+ "properties": {
+ "info": {
+ "$ref": "#/components/schemas/Message.Info"
+ }
+ },
+ "required": [
+ "info"
+ ]
+ }
+ },
+ "required": [
+ "type",
+ "properties"
+ ]
+ },
+ "Message.Info": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "role": {
+ "type": "string",
+ "enum": [
+ "system",
+ "user",
+ "assistant"
+ ]
+ },
+ "parts": {
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/Message.Part"
+ }
+ },
+ "metadata": {
+ "type": "object",
+ "properties": {
+ "time": {
+ "type": "object",
+ "properties": {
+ "created": {
+ "type": "number"
+ },
+ "completed": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "created"
+ ]
+ },
+ "sessionID": {
+ "type": "string"
+ },
+ "tool": {
+ "type": "object",
+ "additionalProperties": {}
+ },
+ "assistant": {
+ "type": "object",
+ "properties": {
+ "modelID": {
+ "type": "string"
+ },
+ "providerID": {
+ "type": "string"
+ },
+ "cost": {
+ "type": "number"
+ },
+ "summary": {
+ "type": "boolean"
+ },
+ "tokens": {
+ "type": "object",
+ "properties": {
+ "input": {
+ "type": "number"
+ },
+ "output": {
+ "type": "number"
+ },
+ "reasoning": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "input",
+ "output",
+ "reasoning"
+ ]
+ }
+ },
+ "required": [
+ "modelID",
+ "providerID",
+ "cost",
+ "tokens"
+ ]
+ }
+ },
+ "required": [
+ "time",
+ "sessionID",
+ "tool"
+ ]
+ }
+ },
+ "required": [
+ "id",
+ "role",
+ "parts",
+ "metadata"
+ ]
+ },
+ "Message.Part": {
+ "oneOf": [
+ {
+ "$ref": "#/components/schemas/Message.Part.Text"
+ },
+ {
+ "$ref": "#/components/schemas/Message.Part.Reasoning"
+ },
+ {
+ "$ref": "#/components/schemas/Message.Part.ToolInvocation"
+ },
+ {
+ "$ref": "#/components/schemas/Message.Part.SourceUrl"
+ },
+ {
+ "$ref": "#/components/schemas/Message.Part.File"
+ },
+ {
+ "$ref": "#/components/schemas/Message.Part.StepStart"
+ }
+ ],
+ "discriminator": {
+ "propertyName": "type",
+ "mapping": {
+ "text": "#/components/schemas/Message.Part.Text",
+ "reasoning": "#/components/schemas/Message.Part.Reasoning",
+ "tool-invocation": "#/components/schemas/Message.Part.ToolInvocation",
+ "source-url": "#/components/schemas/Message.Part.SourceUrl",
+ "file": "#/components/schemas/Message.Part.File",
+ "step-start": "#/components/schemas/Message.Part.StepStart"
+ }
+ }
+ },
+ "Message.Part.Text": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "text"
+ },
+ "text": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "text"
+ ]
+ },
+ "Message.Part.Reasoning": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "reasoning"
+ },
+ "text": {
+ "type": "string"
+ },
+ "providerMetadata": {
+ "type": "object",
+ "additionalProperties": {}
+ }
+ },
+ "required": [
+ "type",
+ "text"
+ ]
+ },
+ "Message.Part.ToolInvocation": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "tool-invocation"
+ },
+ "toolInvocation": {
+ "$ref": "#/components/schemas/Message.ToolInvocation"
+ }
+ },
+ "required": [
+ "type",
+ "toolInvocation"
+ ]
+ },
+ "Message.ToolInvocation": {
+ "oneOf": [
+ {
+ "$ref": "#/components/schemas/Message.ToolInvocation.ToolCall"
+ },
+ {
+ "$ref": "#/components/schemas/Message.ToolInvocation.ToolPartialCall"
+ },
+ {
+ "$ref": "#/components/schemas/Message.ToolInvocation.ToolResult"
+ }
+ ],
+ "discriminator": {
+ "propertyName": "state",
+ "mapping": {
+ "call": "#/components/schemas/Message.ToolInvocation.ToolCall",
+ "partial-call": "#/components/schemas/Message.ToolInvocation.ToolPartialCall",
+ "result": "#/components/schemas/Message.ToolInvocation.ToolResult"
+ }
+ }
+ },
+ "Message.ToolInvocation.ToolCall": {
+ "type": "object",
+ "properties": {
+ "state": {
+ "type": "string",
+ "const": "call"
+ },
+ "step": {
+ "type": "number"
+ },
+ "toolCallId": {
+ "type": "string"
+ },
+ "toolName": {
+ "type": "string"
+ },
+ "args": {}
+ },
+ "required": [
+ "state",
+ "toolCallId",
+ "toolName"
+ ]
+ },
+ "Message.ToolInvocation.ToolPartialCall": {
+ "type": "object",
+ "properties": {
+ "state": {
+ "type": "string",
+ "const": "partial-call"
+ },
+ "step": {
+ "type": "number"
+ },
+ "toolCallId": {
+ "type": "string"
+ },
+ "toolName": {
+ "type": "string"
+ },
+ "args": {}
+ },
+ "required": [
+ "state",
+ "toolCallId",
+ "toolName"
+ ]
+ },
+ "Message.ToolInvocation.ToolResult": {
+ "type": "object",
+ "properties": {
+ "state": {
+ "type": "string",
+ "const": "result"
+ },
+ "step": {
+ "type": "number"
+ },
+ "toolCallId": {
+ "type": "string"
+ },
+ "toolName": {
+ "type": "string"
+ },
+ "args": {},
+ "result": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "state",
+ "toolCallId",
+ "toolName",
+ "result"
+ ]
+ },
+ "Message.Part.SourceUrl": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "source-url"
+ },
+ "sourceId": {
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "providerMetadata": {
+ "type": "object",
+ "additionalProperties": {}
+ }
+ },
+ "required": [
+ "type",
+ "sourceId",
+ "url"
+ ]
+ },
+ "Message.Part.File": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "file"
+ },
+ "mediaType": {
+ "type": "string"
+ },
+ "filename": {
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "type",
+ "mediaType",
+ "url"
+ ]
+ },
+ "Message.Part.StepStart": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "step-start"
+ }
+ },
+ "required": [
+ "type"
+ ]
+ },
+ "Event.lsp.client.diagnostics": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "lsp.client.diagnostics"
+ },
+ "properties": {
+ "type": "object",
+ "properties": {
+ "serverID": {
+ "type": "string"
+ },
+ "path": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "serverID",
+ "path"
+ ]
+ }
+ },
+ "required": [
+ "type",
+ "properties"
+ ]
+ },
+ "Event.permission.updated": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "permission.updated"
+ },
+ "properties": {
+ "$ref": "#/components/schemas/permission.info"
+ }
+ },
+ "required": [
+ "type",
+ "properties"
+ ]
+ },
+ "permission.info": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "sessionID": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "metadata": {
+ "type": "object",
+ "additionalProperties": {}
+ },
+ "time": {
+ "type": "object",
+ "properties": {
+ "created": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "created"
+ ]
+ }
+ },
+ "required": [
+ "id",
+ "sessionID",
+ "title",
+ "metadata",
+ "time"
+ ]
+ },
+ "Event.session.updated": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "const": "session.updated"
+ },
+ "properties": {
+ "type": "object",
+ "properties": {
+ "info": {
+ "$ref": "#/components/schemas/session.info"
+ }
+ },
+ "required": [
+ "info"
+ ]
+ }
+ },
+ "required": [
+ "type",
+ "properties"
+ ]
+ },
+ "session.info": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string",
+ "pattern": "^ses"
+ },
+ "share": {
+ "type": "object",
+ "properties": {
+ "secret": {
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "secret",
+ "url"
+ ]
+ },
+ "title": {
+ "type": "string"
+ },
+ "time": {
+ "type": "object",
+ "properties": {
+ "created": {
+ "type": "number"
+ },
+ "updated": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "created",
+ "updated"
+ ]
+ }
+ },
+ "required": [
+ "id",
+ "title",
+ "time"
+ ]
+ },
+ "Provider.Info": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "options": {
+ "type": "object",
+ "additionalProperties": {}
+ },
+ "models": {
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/Provider.Model"
+ }
+ }
+ },
+ "required": [
+ "id",
+ "name",
+ "models"
+ ]
+ },
+ "Provider.Model": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "cost": {
+ "type": "object",
+ "properties": {
+ "input": {
+ "type": "number"
+ },
+ "inputCached": {
+ "type": "number"
+ },
+ "output": {
+ "type": "number"
+ },
+ "outputCached": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "input",
+ "inputCached",
+ "output",
+ "outputCached"
+ ]
+ },
+ "contextWindow": {
+ "type": "number"
+ },
+ "maxOutputTokens": {
+ "type": "number"
+ },
+ "attachment": {
+ "type": "boolean"
+ },
+ "reasoning": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "id",
+ "cost",
+ "contextWindow",
+ "attachment"
+ ]
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/packages/tui/pkg/client/generated-client.go b/packages/tui/pkg/client/generated-client.go
new file mode 100644
index 000000000..2a662a47e
--- /dev/null
+++ b/packages/tui/pkg/client/generated-client.go
@@ -0,0 +1,2112 @@
+// 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"
+)
+
+// 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"`
+}
+
+// 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"`
+ 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 []ProviderModel `json:"models"`
+ Name string `json:"name"`
+ Options *map[string]interface{} `json:"options,omitempty"`
+}
+
+// ProviderModel defines model for Provider.Model.
+type ProviderModel struct {
+ Attachment bool `json:"attachment"`
+ ContextWindow float32 `json:"contextWindow"`
+ Cost struct {
+ Input float32 `json:"input"`
+ InputCached float32 `json:"inputCached"`
+ Output float32 `json:"output"`
+ OutputCached float32 `json:"outputCached"`
+ } `json:"cost"`
+ Id string `json:"id"`
+ MaxOutputTokens *float32 `json:"maxOutputTokens,omitempty"`
+ 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"`
+}
+
+// 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
+
+// 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
+}
+
+// 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.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 {
+ // 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)
+
+ // 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) 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) 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)
+}
+
+// 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
+}
+
+// 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 {
+ // 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)
+
+ // 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 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 *[]ProviderInfo
+}
+
+// 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 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
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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 []ProviderInfo
+ 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
+}
+
+// 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
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-07-01 07:34:54 +0000