sync

5 files changed, 0 insertions, 2910 deletions

diff --git a/pkg/client/.gitignore b/pkg/client/.gitignore
deleted file mode 100644
index c56971e89..000000000
--- a/pkg/client/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-gen
-generated-*.go
diff --git a/pkg/client/client.go b/pkg/client/client.go
deleted file mode 100644
index bf2d5038e..000000000
--- a/pkg/client/client.go
+++ /dev/null
@@ -1,4 +0,0 @@
-package client
-
-//go:generate bun run ../../js/src/index.ts generate
-//go:generate go tool github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen --package=client --generate=types,client,models -o generated-client.go ./gen/openapi.json
diff --git a/pkg/client/event.go b/pkg/client/event.go
deleted file mode 100644
index f5aab2d26..000000000
--- a/pkg/client/event.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package client
-
-import (
-	"bufio"
-	"context"
-	"encoding/json"
-	"net/http"
-	"strings"
-)
-
-func (c *Client) Event(ctx context.Context) (<-chan any, error) {
-	events := make(chan any)
-	req, err := http.NewRequestWithContext(ctx, "GET", c.Server+"event", nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	go func() {
-		defer close(events)
-		defer resp.Body.Close()
-
-		scanner := bufio.NewScanner(resp.Body)
-		for scanner.Scan() {
-			line := scanner.Text()
-			if strings.HasPrefix(line, "data: ") {
-				data := strings.TrimPrefix(line, "data: ")
-
-				var event Event
-				if err := json.Unmarshal([]byte(data), &event); err != nil {
-					continue
-				}
-
-				val, err := event.ValueByDiscriminator()
-				if err != nil {
-					continue
-				}
-
-				select {
-				case events <- val:
-				case <-ctx.Done():
-					return
-				}
-			}
-		}
-	}()
-
-	return events, nil
-}
diff --git a/pkg/client/gen/openapi.json b/pkg/client/gen/openapi.json
deleted file mode 100644
index c5f1c64b3..000000000
--- a/pkg/client/gen/openapi.json
+++ /dev/null
@@ -1,898 +0,0 @@
-{
-  "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"
-      }
-    },
-    "/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.lsp.client.diagnostics"
-          },
-          {
-            "$ref": "#/components/schemas/Event.message.updated"
-          },
-          {
-            "$ref": "#/components/schemas/Event.session.updated"
-          }
-        ],
-        "discriminator": {
-          "propertyName": "type",
-          "mapping": {
-            "storage.write": "#/components/schemas/Event.storage.write",
-            "lsp.client.diagnostics": "#/components/schemas/Event.lsp.client.diagnostics",
-            "message.updated": "#/components/schemas/Event.message.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.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.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.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/pkg/client/generated-client.go b/pkg/client/generated-client.go
deleted file mode 100644
index 925468a61..000000000
--- a/pkg/client/generated-client.go
+++ /dev/null
@@ -1,1953 +0,0 @@
-// 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"`
-}
-
-// 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"`
-}
-
-// 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
-}
-
-// 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
-}
-
-// 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
-}
-
-// 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 "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)
-
-	// 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) 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
-}
-
-// 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)
-
-	// 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 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)
-}
-
-// 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
-}
-
-// 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
-}