client

type AdminReadiness struct {
	AppVersion string `json:"appVersion"`

	// Backup The status of an operator-written backup completion marker. A current marker proves only that the backup command completed; it is not an archive-content verification result.
	Backup           BackupFreshness              `json:"backup"`
	Commit           *string                      `json:"commit,omitempty"`
	DatabaseDriver   AdminReadinessDatabaseDriver `json:"databaseDriver"`
	MigrationDirty   bool                         `json:"migrationDirty"`
	MigrationVersion int                          `json:"migrationVersion"`
	Upstreams        []UpstreamHealth             `json:"upstreams"`
}

type AdminReadinessDatabaseDriver string

type AuthStatus struct {
	Authenticated bool `json:"authenticated"`

	// NeedsSetup True when no users exist yet (first-run bootstrap).
	NeedsSetup bool  `json:"needsSetup"`
	User       *User `json:"user,omitempty"`
}

type BackupFreshness struct {
	CompletedAt *time.Time             `json:"completedAt,omitempty"`
	Driver      *BackupFreshnessDriver `json:"driver,omitempty"`
	State       BackupFreshnessState   `json:"state"`
}

type BackupFreshnessDriver string

type BackupFreshnessState string

type BadRequest = Error

type Chat struct {
	Id openapi_types.UUID `json:"id"`

	// Model The model id the chat was created with (used for continuation).
	Model string `json:"model"`

	// Settings Per-chat model-generation settings. Every field is optional; an omitted field is unset — the provider default applies (temperature / topP / reasoningEffort / maxOutputTokens). maxHistoryTokens defaults to 100000 and caps the complete outbound prompt, including the sticky system message and current user message.
	Settings *ChatSettings `json:"settings,omitempty"`
	Title    string        `json:"title"`
}

type ChatList struct {
	Items  []ChatSummary `json:"items"`
	Limit  int           `json:"limit"`
	Offset int           `json:"offset"`
	Total  int           `json:"total"`
}

type ChatMCPServer struct {
	// Enabled Whether this server's tools are available to this chat.
	Enabled bool               `json:"enabled"`
	Id      openapi_types.UUID `json:"id"`
	Name    string             `json:"name"`

	// Status Live global connection status of the server.
	Status ChatMCPServerStatus `json:"status"`
}

type ChatMCPServerStatus string

type ChatMCPServerUpdate struct {
	// Enabled Enable or disable this server's tools for this chat.
	Enabled bool `json:"enabled"`
}

type ChatSettings struct {
	MaxHistoryTokens *int                         `json:"maxHistoryTokens,omitempty"`
	MaxOutputTokens  *int                         `json:"maxOutputTokens,omitempty"`
	ReasoningEffort  *ChatSettingsReasoningEffort `json:"reasoningEffort,omitempty"`
	Temperature      *float64                     `json:"temperature,omitempty"`
	TopP             *float64                     `json:"topP,omitempty"`
}

type ChatSettingsReasoningEffort string

type ChatSummary struct {
	CreatedAt time.Time          `json:"createdAt"`
	Id        openapi_types.UUID `json:"id"`
	Title     string             `json:"title"`
	UpdatedAt time.Time          `json:"updatedAt"`
}

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
}

type ClientInterface interface {

	// GetAdminReadiness Get the redacted operational readiness snapshot (admin).
	//
	// Corresponds with GET /admin/readiness (the `GetAdminReadiness` operationId).
	GetAdminReadiness(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// LoginWithBody Log in with username + password.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /auth/login (the `Login` operationId).
	LoginWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Login Log in with username + password.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /auth/login (the `Login` operationId).
	Login(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Logout Revoke the current session.
	//
	// Corresponds with POST /auth/logout (the `Logout` operationId).
	Logout(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// SetupWithBody Bootstrap the first admin user (one-shot).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /auth/setup (the `Setup` operationId).
	SetupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// Setup Bootstrap the first admin user (one-shot).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /auth/setup (the `Setup` operationId).
	Setup(ctx context.Context, body SetupJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetAuthStatus Whether setup is needed and whether the caller is authenticated.
	//
	// Corresponds with GET /auth/status (the `GetAuthStatus` operationId).
	GetAuthStatus(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListChats List the caller's chats, paginated.
	//
	// Corresponds with GET /chats (the `ListChats` operationId).
	ListChats(ctx context.Context, params *ListChatsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateChatWithBody Create a chat and stream the first assistant turn (SSE).
	//
	// Streams Anthropic-style SSE. The new chat id is carried in the message_start event's stream_id. Advisory chat_status events report connecting, waiting_first_token, streaming, running_tool, or retrying; clients must treat them as ephemeral progress metadata rather than durable assistant content. If a real stream stops after useful output, GET /chats/{chatId}/messages returns that assistant checkpoint with incomplete=true; it is not included in later model context.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /chats (the `CreateChat` operationId).
	CreateChatWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateChat Create a chat and stream the first assistant turn (SSE).
	//
	// Streams Anthropic-style SSE. The new chat id is carried in the message_start event's stream_id. Advisory chat_status events report connecting, waiting_first_token, streaming, running_tool, or retrying; clients must treat them as ephemeral progress metadata rather than durable assistant content. If a real stream stops after useful output, GET /chats/{chatId}/messages returns that assistant checkpoint with incomplete=true; it is not included in later model context.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /chats (the `CreateChat` operationId).
	CreateChat(ctx context.Context, body CreateChatJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetOrCreateEmptyChat Get the caller's reusable "empty chat" (no messages yet), creating one if none exists.
	//
	// At most one empty chat is kept per user: repeated calls before any message is sent all resolve to the SAME chat id, so a client's "New chat" action never piles up unused rows. Once the chat's first message is sent (POST /chats/{chatId}), it stops being empty and a later call creates/returns a different chat.
	//
	// Corresponds with POST /chats/empty (the `GetOrCreateEmptyChat` operationId).
	GetOrCreateEmptyChat(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteChat Soft-delete one caller-owned chat.
	//
	// Corresponds with DELETE /chats/{chatId} (the `DeleteChat` operationId).
	DeleteChat(ctx context.Context, chatId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetChat Get a chat's metadata (settings, model, title) — no messages.
	//
	// Returns chat metadata only. Fetch messages via GET /api/v1/chats/{chatId}/messages.
	//
	// Corresponds with GET /chats/{chatId} (the `GetChat` operationId).
	GetChat(ctx context.Context, chatId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RenameChatWithBody Rename a chat.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /chats/{chatId} (the `RenameChat` operationId).
	RenameChatWithBody(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// RenameChat Rename a chat.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /chats/{chatId} (the `RenameChat` operationId).
	RenameChat(ctx context.Context, chatId openapi_types.UUID, body RenameChatJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ContinueChatWithBody Continue a chat and stream the next assistant turn (SSE).
	//
	// Streams Anthropic-style SSE plus advisory chat_status progress events. A status is emitted only after its corresponding provider or tool lifecycle transition; it carries no prompt, tool, or provider payload.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /chats/{chatId} (the `ContinueChat` operationId).
	ContinueChatWithBody(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ContinueChat Continue a chat and stream the next assistant turn (SSE).
	//
	// Streams Anthropic-style SSE plus advisory chat_status progress events. A status is emitted only after its corresponding provider or tool lifecycle transition; it carries no prompt, tool, or provider payload.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /chats/{chatId} (the `ContinueChat` operationId).
	ContinueChat(ctx context.Context, chatId openapi_types.UUID, body ContinueChatJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PreviewChatContextWithBody Preview the exact context selected for an unsent chat message.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /chats/{chatId}/context-preview (the `PreviewChatContext` operationId).
	PreviewChatContextWithBody(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// PreviewChatContext Preview the exact context selected for an unsent chat message.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /chats/{chatId}/context-preview (the `PreviewChatContext` operationId).
	PreviewChatContext(ctx context.Context, chatId openapi_types.UUID, body PreviewChatContextJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListChatMCPServers List the MCP servers with each one's per-chat enablement + status.
	//
	// The MCP servers as this chat sees them: identity, live global connection status, and whether each is enabled for this chat. Ownership-checked, so a chat's owner sees it without admin access.
	//
	// Corresponds with GET /chats/{chatId}/mcp-servers (the `ListChatMCPServers` operationId).
	ListChatMCPServers(ctx context.Context, chatId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateChatMCPServerWithBody Enable or disable one MCP server for this chat.
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /chats/{chatId}/mcp-servers/{serverId} (the `UpdateChatMCPServer` operationId).
	UpdateChatMCPServerWithBody(ctx context.Context, chatId openapi_types.UUID, serverId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateChatMCPServer Enable or disable one MCP server for this chat.
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /chats/{chatId}/mcp-servers/{serverId} (the `UpdateChatMCPServer` operationId).
	UpdateChatMCPServer(ctx context.Context, chatId openapi_types.UUID, serverId openapi_types.UUID, body UpdateChatMCPServerJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListChatMessages List a chat's messages, oldest-first, paginated.
	//
	// Corresponds with GET /chats/{chatId}/messages (the `ListChatMessages` operationId).
	ListChatMessages(ctx context.Context, chatId openapi_types.UUID, params *ListChatMessagesParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateChatSettingsWithBody Update a chat's model-generation settings.
	//
	// Full replacement of the chat's settings object: a field omitted from the body clears that setting (back to the provider default; history returns to its 100000-token default).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /chats/{chatId}/settings (the `UpdateChatSettings` operationId).
	UpdateChatSettingsWithBody(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateChatSettings Update a chat's model-generation settings.
	//
	// Full replacement of the chat's settings object: a field omitted from the body clears that setting (back to the provider default; history returns to its 100000-token default).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /chats/{chatId}/settings (the `UpdateChatSettings` operationId).
	UpdateChatSettings(ctx context.Context, chatId openapi_types.UUID, body UpdateChatSettingsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetHealth Liveness probe.
	//
	// Corresponds with GET /healthz (the `GetHealth` operationId).
	GetHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ImportMCPWithBody Import MCP servers from a Claude-style .mcp.json (admin).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /mcp/import (the `ImportMCP` operationId).
	ImportMCPWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ImportMCP Import MCP servers from a Claude-style .mcp.json (admin).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /mcp/import (the `ImportMCP` operationId).
	ImportMCP(ctx context.Context, body ImportMCPJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListMCPServers List configured MCP servers (admin).
	//
	// Corresponds with GET /mcp/servers (the `ListMCPServers` operationId).
	ListMCPServers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateMCPServerWithBody Add an MCP server (admin).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /mcp/servers (the `CreateMCPServer` operationId).
	CreateMCPServerWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateMCPServer Add an MCP server (admin).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /mcp/servers (the `CreateMCPServer` operationId).
	CreateMCPServer(ctx context.Context, body CreateMCPServerJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteMCPServer Remove an MCP server (admin).
	//
	// Corresponds with DELETE /mcp/servers/{serverId} (the `DeleteMCPServer` operationId).
	DeleteMCPServer(ctx context.Context, serverId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateMCPServerWithBody Edit an MCP server and reconnect (admin).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with PATCH /mcp/servers/{serverId} (the `UpdateMCPServer` operationId).
	UpdateMCPServerWithBody(ctx context.Context, serverId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// UpdateMCPServer Edit an MCP server and reconnect (admin).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with PATCH /mcp/servers/{serverId} (the `UpdateMCPServer` operationId).
	UpdateMCPServer(ctx context.Context, serverId openapi_types.UUID, body UpdateMCPServerJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ReconnectMCPServer Reconnect an MCP server in the background (admin).
	//
	// Corresponds with POST /mcp/servers/{serverId}/reconnect (the `ReconnectMCPServer` operationId).
	ReconnectMCPServer(ctx context.Context, serverId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListMCPServerTools List a connected MCP server's tools (admin).
	//
	// Corresponds with GET /mcp/servers/{serverId}/tools (the `ListMCPServerTools` operationId).
	ListMCPServerTools(ctx context.Context, serverId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListModels Merged model list across all configured upstreams.
	//
	// Corresponds with GET /models (the `ListModels` operationId).
	ListModels(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListUpstreamHealth List redacted LLM upstream health snapshots (admin).
	//
	// Corresponds with GET /upstreams (the `ListUpstreamHealth` operationId).
	ListUpstreamHealth(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// ListUsers List users (admin).
	//
	// Corresponds with GET /users (the `ListUsers` operationId).
	ListUsers(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUserWithBody Provision a user (admin).
	//
	// Takes any type of body and a specified content type.
	//
	// Corresponds with POST /users (the `CreateUser` operationId).
	CreateUserWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	// CreateUser Provision a user (admin).
	//
	// Takes a body of the `application/json` content type.
	//
	// Corresponds with POST /users (the `CreateUser` operationId).
	CreateUser(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DeleteUser Delete a user (admin).
	//
	// Corresponds with DELETE /users/{userId} (the `DeleteUser` operationId).
	DeleteUser(ctx context.Context, userId openapi_types.UUID, reqEditors ...RequestEditorFn) (*http.Response, error)
}

type ClientOption func(*Client) error

type ClientWithResponses struct {
	ClientInterface
}

type ClientWithResponsesInterface interface {

	// GetAdminReadinessWithResponse Get the redacted operational readiness snapshot (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /admin/readiness (the `GetAdminReadiness` operationId).
	GetAdminReadinessWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAdminReadinessResponse, error)

	// LoginWithBodyWithResponse Log in with username + password.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/login (the `Login` operationId).
	LoginWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*LoginResponse, error)

	// LoginWithResponse Log in with username + password.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/login (the `Login` operationId).
	LoginWithResponse(ctx context.Context, body LoginJSONRequestBody, reqEditors ...RequestEditorFn) (*LoginResponse, error)

	// LogoutWithResponse Revoke the current session.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/logout (the `Logout` operationId).
	LogoutWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*LogoutResponse, error)

	// SetupWithBodyWithResponse Bootstrap the first admin user (one-shot).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/setup (the `Setup` operationId).
	SetupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*SetupResponse, error)

	// SetupWithResponse Bootstrap the first admin user (one-shot).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /auth/setup (the `Setup` operationId).
	SetupWithResponse(ctx context.Context, body SetupJSONRequestBody, reqEditors ...RequestEditorFn) (*SetupResponse, error)

	// GetAuthStatusWithResponse Whether setup is needed and whether the caller is authenticated.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /auth/status (the `GetAuthStatus` operationId).
	GetAuthStatusWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetAuthStatusResponse, error)

	// ListChatsWithResponse List the caller's chats, paginated.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /chats (the `ListChats` operationId).
	ListChatsWithResponse(ctx context.Context, params *ListChatsParams, reqEditors ...RequestEditorFn) (*ListChatsResponse, error)

	// CreateChatWithBodyWithResponse Create a chat and stream the first assistant turn (SSE).
	//
	// Streams Anthropic-style SSE. The new chat id is carried in the message_start event's stream_id. Advisory chat_status events report connecting, waiting_first_token, streaming, running_tool, or retrying; clients must treat them as ephemeral progress metadata rather than durable assistant content. If a real stream stops after useful output, GET /chats/{chatId}/messages returns that assistant checkpoint with incomplete=true; it is not included in later model context.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats (the `CreateChat` operationId).
	CreateChatWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateChatResponse, error)

	// CreateChatWithResponse Create a chat and stream the first assistant turn (SSE).
	//
	// Streams Anthropic-style SSE. The new chat id is carried in the message_start event's stream_id. Advisory chat_status events report connecting, waiting_first_token, streaming, running_tool, or retrying; clients must treat them as ephemeral progress metadata rather than durable assistant content. If a real stream stops after useful output, GET /chats/{chatId}/messages returns that assistant checkpoint with incomplete=true; it is not included in later model context.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats (the `CreateChat` operationId).
	CreateChatWithResponse(ctx context.Context, body CreateChatJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateChatResponse, error)

	// GetOrCreateEmptyChatWithResponse Get the caller's reusable "empty chat" (no messages yet), creating one if none exists.
	//
	// At most one empty chat is kept per user: repeated calls before any message is sent all resolve to the SAME chat id, so a client's "New chat" action never piles up unused rows. Once the chat's first message is sent (POST /chats/{chatId}), it stops being empty and a later call creates/returns a different chat.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats/empty (the `GetOrCreateEmptyChat` operationId).
	GetOrCreateEmptyChatWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetOrCreateEmptyChatResponse, error)

	// DeleteChatWithResponse Soft-delete one caller-owned chat.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /chats/{chatId} (the `DeleteChat` operationId).
	DeleteChatWithResponse(ctx context.Context, chatId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteChatResponse, error)

	// GetChatWithResponse Get a chat's metadata (settings, model, title) — no messages.
	//
	// Returns chat metadata only. Fetch messages via GET /api/v1/chats/{chatId}/messages.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /chats/{chatId} (the `GetChat` operationId).
	GetChatWithResponse(ctx context.Context, chatId openapi_types.UUID, reqEditors ...RequestEditorFn) (*GetChatResponse, error)

	// RenameChatWithBodyWithResponse Rename a chat.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /chats/{chatId} (the `RenameChat` operationId).
	RenameChatWithBodyWithResponse(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*RenameChatResponse, error)

	// RenameChatWithResponse Rename a chat.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /chats/{chatId} (the `RenameChat` operationId).
	RenameChatWithResponse(ctx context.Context, chatId openapi_types.UUID, body RenameChatJSONRequestBody, reqEditors ...RequestEditorFn) (*RenameChatResponse, error)

	// ContinueChatWithBodyWithResponse Continue a chat and stream the next assistant turn (SSE).
	//
	// Streams Anthropic-style SSE plus advisory chat_status progress events. A status is emitted only after its corresponding provider or tool lifecycle transition; it carries no prompt, tool, or provider payload.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats/{chatId} (the `ContinueChat` operationId).
	ContinueChatWithBodyWithResponse(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ContinueChatResponse, error)

	// ContinueChatWithResponse Continue a chat and stream the next assistant turn (SSE).
	//
	// Streams Anthropic-style SSE plus advisory chat_status progress events. A status is emitted only after its corresponding provider or tool lifecycle transition; it carries no prompt, tool, or provider payload.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats/{chatId} (the `ContinueChat` operationId).
	ContinueChatWithResponse(ctx context.Context, chatId openapi_types.UUID, body ContinueChatJSONRequestBody, reqEditors ...RequestEditorFn) (*ContinueChatResponse, error)

	// PreviewChatContextWithBodyWithResponse Preview the exact context selected for an unsent chat message.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats/{chatId}/context-preview (the `PreviewChatContext` operationId).
	PreviewChatContextWithBodyWithResponse(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PreviewChatContextResponse, error)

	// PreviewChatContextWithResponse Preview the exact context selected for an unsent chat message.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /chats/{chatId}/context-preview (the `PreviewChatContext` operationId).
	PreviewChatContextWithResponse(ctx context.Context, chatId openapi_types.UUID, body PreviewChatContextJSONRequestBody, reqEditors ...RequestEditorFn) (*PreviewChatContextResponse, error)

	// ListChatMCPServersWithResponse List the MCP servers with each one's per-chat enablement + status.
	//
	// The MCP servers as this chat sees them: identity, live global connection status, and whether each is enabled for this chat. Ownership-checked, so a chat's owner sees it without admin access.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /chats/{chatId}/mcp-servers (the `ListChatMCPServers` operationId).
	ListChatMCPServersWithResponse(ctx context.Context, chatId openapi_types.UUID, reqEditors ...RequestEditorFn) (*ListChatMCPServersResponse, error)

	// UpdateChatMCPServerWithBodyWithResponse Enable or disable one MCP server for this chat.
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /chats/{chatId}/mcp-servers/{serverId} (the `UpdateChatMCPServer` operationId).
	UpdateChatMCPServerWithBodyWithResponse(ctx context.Context, chatId openapi_types.UUID, serverId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateChatMCPServerResponse, error)

	// UpdateChatMCPServerWithResponse Enable or disable one MCP server for this chat.
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /chats/{chatId}/mcp-servers/{serverId} (the `UpdateChatMCPServer` operationId).
	UpdateChatMCPServerWithResponse(ctx context.Context, chatId openapi_types.UUID, serverId openapi_types.UUID, body UpdateChatMCPServerJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateChatMCPServerResponse, error)

	// ListChatMessagesWithResponse List a chat's messages, oldest-first, paginated.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /chats/{chatId}/messages (the `ListChatMessages` operationId).
	ListChatMessagesWithResponse(ctx context.Context, chatId openapi_types.UUID, params *ListChatMessagesParams, reqEditors ...RequestEditorFn) (*ListChatMessagesResponse, error)

	// UpdateChatSettingsWithBodyWithResponse Update a chat's model-generation settings.
	//
	// Full replacement of the chat's settings object: a field omitted from the body clears that setting (back to the provider default; history returns to its 100000-token default).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /chats/{chatId}/settings (the `UpdateChatSettings` operationId).
	UpdateChatSettingsWithBodyWithResponse(ctx context.Context, chatId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateChatSettingsResponse, error)

	// UpdateChatSettingsWithResponse Update a chat's model-generation settings.
	//
	// Full replacement of the chat's settings object: a field omitted from the body clears that setting (back to the provider default; history returns to its 100000-token default).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /chats/{chatId}/settings (the `UpdateChatSettings` operationId).
	UpdateChatSettingsWithResponse(ctx context.Context, chatId openapi_types.UUID, body UpdateChatSettingsJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateChatSettingsResponse, error)

	// GetHealthWithResponse Liveness probe.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /healthz (the `GetHealth` operationId).
	GetHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetHealthResponse, error)

	// ImportMCPWithBodyWithResponse Import MCP servers from a Claude-style .mcp.json (admin).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /mcp/import (the `ImportMCP` operationId).
	ImportMCPWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*ImportMCPResponse, error)

	// ImportMCPWithResponse Import MCP servers from a Claude-style .mcp.json (admin).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /mcp/import (the `ImportMCP` operationId).
	ImportMCPWithResponse(ctx context.Context, body ImportMCPJSONRequestBody, reqEditors ...RequestEditorFn) (*ImportMCPResponse, error)

	// ListMCPServersWithResponse List configured MCP servers (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /mcp/servers (the `ListMCPServers` operationId).
	ListMCPServersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListMCPServersResponse, error)

	// CreateMCPServerWithBodyWithResponse Add an MCP server (admin).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /mcp/servers (the `CreateMCPServer` operationId).
	CreateMCPServerWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateMCPServerResponse, error)

	// CreateMCPServerWithResponse Add an MCP server (admin).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /mcp/servers (the `CreateMCPServer` operationId).
	CreateMCPServerWithResponse(ctx context.Context, body CreateMCPServerJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateMCPServerResponse, error)

	// DeleteMCPServerWithResponse Remove an MCP server (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /mcp/servers/{serverId} (the `DeleteMCPServer` operationId).
	DeleteMCPServerWithResponse(ctx context.Context, serverId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteMCPServerResponse, error)

	// UpdateMCPServerWithBodyWithResponse Edit an MCP server and reconnect (admin).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /mcp/servers/{serverId} (the `UpdateMCPServer` operationId).
	UpdateMCPServerWithBodyWithResponse(ctx context.Context, serverId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*UpdateMCPServerResponse, error)

	// UpdateMCPServerWithResponse Edit an MCP server and reconnect (admin).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with PATCH /mcp/servers/{serverId} (the `UpdateMCPServer` operationId).
	UpdateMCPServerWithResponse(ctx context.Context, serverId openapi_types.UUID, body UpdateMCPServerJSONRequestBody, reqEditors ...RequestEditorFn) (*UpdateMCPServerResponse, error)

	// ReconnectMCPServerWithResponse Reconnect an MCP server in the background (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /mcp/servers/{serverId}/reconnect (the `ReconnectMCPServer` operationId).
	ReconnectMCPServerWithResponse(ctx context.Context, serverId openapi_types.UUID, reqEditors ...RequestEditorFn) (*ReconnectMCPServerResponse, error)

	// ListMCPServerToolsWithResponse List a connected MCP server's tools (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /mcp/servers/{serverId}/tools (the `ListMCPServerTools` operationId).
	ListMCPServerToolsWithResponse(ctx context.Context, serverId openapi_types.UUID, reqEditors ...RequestEditorFn) (*ListMCPServerToolsResponse, error)

	// ListModelsWithResponse Merged model list across all configured upstreams.
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /models (the `ListModels` operationId).
	ListModelsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListModelsResponse, error)

	// ListUpstreamHealthWithResponse List redacted LLM upstream health snapshots (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /upstreams (the `ListUpstreamHealth` operationId).
	ListUpstreamHealthWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListUpstreamHealthResponse, error)

	// ListUsersWithResponse List users (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with GET /users (the `ListUsers` operationId).
	ListUsersWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*ListUsersResponse, error)

	// CreateUserWithBodyWithResponse Provision a user (admin).
	//
	// Takes any type of body and a specified content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /users (the `CreateUser` operationId).
	CreateUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// CreateUserWithResponse Provision a user (admin).
	//
	// Takes a body of the `application/json` content type, and returns a wrapper object for the known response body format(s).
	//
	// Corresponds with POST /users (the `CreateUser` operationId).
	CreateUserWithResponse(ctx context.Context, body CreateUserJSONRequestBody, reqEditors ...RequestEditorFn) (*CreateUserResponse, error)

	// DeleteUserWithResponse Delete a user (admin).
	//
	// Returns a wrapper object for the known response body format(s).
	//
	// Corresponds with DELETE /users/{userId} (the `DeleteUser` operationId).
	DeleteUserWithResponse(ctx context.Context, userId openapi_types.UUID, reqEditors ...RequestEditorFn) (*DeleteUserResponse, error)
}

type Conflict = Error

type ContinueChatJSONRequestBody = ContinueChatRequest

type ContinueChatRequest struct {
	Message string `json:"message"`

	// Model Model for this and subsequent turns; switching it updates the chat's model. Omit to keep the chat's current model.
	Model *string `json:"model,omitempty"`
}

type ContinueChatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type CreateChatJSONRequestBody = CreateChatRequest

type CreateChatRequest struct {
	Message string `json:"message"`
	Model   string `json:"model"`
}

type CreateChatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
}

type CreateMCPServerJSONRequestBody = CreateMCPServerRequest

type CreateMCPServerRequest struct {
	Args      *[]string                       `json:"args,omitempty"`
	Command   *string                         `json:"command,omitempty"`
	Env       *map[string]string              `json:"env,omitempty"`
	Headers   *map[string]string              `json:"headers,omitempty"`
	Name      string                          `json:"name"`
	Transport CreateMCPServerRequestTransport `json:"transport"`
	Url       *string                         `json:"url,omitempty"`
}

type CreateMCPServerRequestTransport string

type CreateMCPServerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *MCPServer
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Conflict
}

type CreateUserJSONRequestBody = CreateUserRequest

type CreateUserRequest struct {
	IsAdmin  *bool  `json:"isAdmin,omitempty"`
	Password string `json:"password"`
	Username string `json:"username"`
}

type CreateUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON201 the response for an HTTP 201 `application/json` response
	JSON201 *User
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON409 the response for an HTTP 409 `application/json` response
	JSON409 *Conflict
}

type Credentials struct {
	Password string `json:"password"`
	Username string `json:"username"`
}

type DeleteChatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type DeleteMCPServerResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type DeleteUserResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type Error struct {
	Code    string                  `json:"code"`
	Details *map[string]interface{} `json:"details,omitempty"`
	Message string                  `json:"message"`
}

type GetAdminReadinessResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *AdminReadiness
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type GetAuthStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *AuthStatus
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *GetAuthStatusResponse200Headers
}

type GetAuthStatusResponse200Headers struct {
	SetCookie *string
}

type GetChatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Chat
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type GetHealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Health
}

type GetOrCreateEmptyChatResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *Chat
}

type Health struct {
	Status string `json:"status"`
}

type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type ImportMCPJSONRequestBody = ImportMCPRequest

type ImportMCPRequest struct {
	// Content Raw .mcp.json file content (Claude-style).
	Content string `json:"content"`
}

type ImportMCPResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *MCPImportResult
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
}

type ListChatMCPServersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]ChatMCPServer
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type ListChatMessagesParams struct {
	Limit  *int `form:"limit,omitempty" json:"limit,omitempty"`
	Offset *int `form:"offset,omitempty" json:"offset,omitempty"`
}

type ListChatMessagesResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *MessageList
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type ListChatsParams struct {
	Limit  *int `form:"limit,omitempty" json:"limit,omitempty"`
	Offset *int `form:"offset,omitempty" json:"offset,omitempty"`

	// Search Case-insensitive literal title search.
	Search *string `form:"search,omitempty" json:"search,omitempty"`
}

type ListChatsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *ChatList
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type ListMCPServerToolsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]MCPTool
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type ListMCPServersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]MCPServer
}

type ListModelsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]Model
}

type ListUpstreamHealthResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]UpstreamHealth
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type ListUsersResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *[]User
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
}

type LoginJSONRequestBody = Credentials

type LoginResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *User
	// JSON401 the response for an HTTP 401 `application/json` response
	JSON401 *Unauthorized
	// Headers200 the parsed response headers for an HTTP 200 response
	Headers200 *LoginResponse200Headers
}

type LoginResponse200Headers struct {
	SetCookie *string
}

type LogoutResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

type MCPImportResult struct {
	Imported []MCPServer `json:"imported"`
}

type MCPServer struct {
	// Args Command arguments (stdio transport).
	Args    *[]string `json:"args,omitempty"`
	Command *string   `json:"command,omitempty"`
	Enabled bool      `json:"enabled"`

	// Env Environment variables (stdio transport), decrypted for edit prefill. Admin-only response; sealed at rest, never logged.
	Env *map[string]string `json:"env,omitempty"`

	// Headers HTTP headers (http transport). Authorization values are returned as '<scheme> [SECRET]' for edit prefill; resubmitting that unchanged value preserves the existing sealed credential. Other header values are returned as configured. Admin-only response; sealed at rest and never logged (the request logger records no bodies).
	Headers *map[string]string `json:"headers,omitempty"`
	Id      openapi_types.UUID `json:"id"`

	// LastConnectionAttemptAt UTC time at which the most recent connection attempt started.
	LastConnectionAttemptAt *time.Time `json:"lastConnectionAttemptAt,omitempty"`

	// LastConnectionFailureAt UTC time at which this server most recently failed to connect or disconnected unexpectedly.
	LastConnectionFailureAt *time.Time `json:"lastConnectionFailureAt,omitempty"`

	// LastConnectionLatencyMs Elapsed milliseconds for the most recent completed connection attempt.
	LastConnectionLatencyMs *int `json:"lastConnectionLatencyMs,omitempty"`

	// LastError Most recent connection or unexpected-disconnect error detail. Admin-only and never includes decrypted credentials.
	LastError *string `json:"lastError,omitempty"`

	// LastSuccessfulConnectionAt UTC time at which this server most recently connected successfully.
	LastSuccessfulConnectionAt *time.Time `json:"lastSuccessfulConnectionAt,omitempty"`
	Name                       string     `json:"name"`

	// Status Live connection state of the server.
	Status MCPServerStatus `json:"status"`

	// StatusError Error detail, present when status is failed.
	StatusError *string `json:"statusError,omitempty"`

	// StatusReason Coarse failure classification, present when status is failed.
	StatusReason *MCPServerStatusReason `json:"statusReason,omitempty"`

	// ToolCount Number of tools discovered, present when connected.
	ToolCount *int               `json:"toolCount,omitempty"`
	Transport MCPServerTransport `json:"transport"`
	Url       *string            `json:"url,omitempty"`
}

type MCPServerStatus string

type MCPServerStatusReason string

type MCPServerTransport string

type MCPTool struct {
	Description string `json:"description"`

	// Name Unqualified tool name (no server prefix).
	Name string `json:"name"`

	// Parameters The tool's input JSON Schema.
	Parameters map[string]interface{} `json:"parameters"`
}

type Message struct {
	Content   string             `json:"content"`
	CreatedAt time.Time          `json:"createdAt"`
	Id        openapi_types.UUID `json:"id"`

	// Incomplete True when this is an interrupted turn checkpoint. It is visible on reload but is never replayed into a future model request.
	Incomplete *bool `json:"incomplete,omitempty"`
	IsError    *bool `json:"isError,omitempty"`

	// Model The model that completed this turn. Omitted for messages created before model attribution was introduced.
	Model      *string            `json:"model,omitempty"`
	Role       MessageRole        `json:"role"`
	Thinking   *string            `json:"thinking,omitempty"`
	ToolCallId *string            `json:"toolCallId,omitempty"`
	ToolCalls  *[]MessageToolCall `json:"toolCalls,omitempty"`
}

type MessageList struct {
	Items  []Message `json:"items"`
	Limit  int       `json:"limit"`
	Offset int       `json:"offset"`
	Total  int       `json:"total"`
}

type MessageRole string

type MessageToolCall struct {
	Arguments string `json:"arguments"`
	Id        string `json:"id"`
	Name      string `json:"name"`
}

type Model struct {
	// Alias A friendly instance-local model name for the picker.
	Alias *string `json:"alias,omitempty"`

	// Availability The model was advertised by its upstream during startup discovery.
	Availability  ModelAvailability `json:"availability"`
	ContextWindow *int              `json:"contextWindow,omitempty"`

	// Default Whether this is the instance's configured default model.
	Default bool `json:"default"`

	// ExpectedFirstTokenLatencyMs Instance-configured expected time to first token, in milliseconds.
	ExpectedFirstTokenLatencyMs *int64 `json:"expectedFirstTokenLatencyMs,omitempty"`
	Id                          string `json:"id"`

	// InputPricePerMillionTokens Price for one million tokens. Amount is a decimal string in the currency's smallest unit, avoiding floating-point loss in clients.
	InputPricePerMillionTokens *TokenPrice `json:"inputPricePerMillionTokens,omitempty"`
	MaxOutputTokens            *int        `json:"maxOutputTokens,omitempty"`

	// OutputPricePerMillionTokens Price for one million tokens. Amount is a decimal string in the currency's smallest unit, avoiding floating-point loss in clients.
	OutputPricePerMillionTokens *TokenPrice `json:"outputPricePerMillionTokens,omitempty"`
	SupportsFiles               *bool       `json:"supportsFiles,omitempty"`
	SupportsReasoning           *bool       `json:"supportsReasoning,omitempty"`
	SupportsTools               *bool       `json:"supportsTools,omitempty"`
	SupportsVision              *bool       `json:"supportsVision,omitempty"`
	Upstream                    string      `json:"upstream"`
}

type ModelAvailability string

type NotFound = Error

type PreviewChatContextJSONRequestBody = PromptContextPreviewRequest

type PreviewChatContextResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	// JSON200 the response for an HTTP 200 `application/json` response
	JSON200 *PromptContextPreview
	// JSON400 the response for an HTTP 400 `application/json` response
	JSON400 *BadRequest
	// JSON404 the response for an HTTP 404 `application/json` response
	JSON404 *NotFound
}

type PromptContextPreview struct {
	AvailableTokens      int `json:"availableTokens"`
	BudgetTokens         int `json:"budgetTokens"`
	CurrentMessageTokens int `json:"currentMessageTokens"`
	HistoryTokens        int `json:"historyTokens"`
	OmittedMessages      int `json:"omittedMessages"`
	OmittedTurns         int `json:"omittedTurns"`
	RetainedMessages     int `json:"retainedMessages"`
	RetainedTurns        int `json:"retainedTurns"`
	SystemTokens         int `json:"systemTokens"`
	TotalTokens          int `json:"totalTokens"`
}