Files
mtusi2026lab4/backend/internal/adapter/handler/api.gen.go
T

4414 lines
130 KiB
Go

// Package handler provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.8.0 DO NOT EDIT.
package handler
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"github.com/go-chi/chi/v5"
"github.com/oapi-codegen/runtime"
openapi_types "github.com/oapi-codegen/runtime/types"
)
// Defines values for AttachmentContentType.
const (
AttachmentContentTypeImagejpeg AttachmentContentType = "image/jpeg"
AttachmentContentTypeImagepng AttachmentContentType = "image/png"
)
// Valid indicates whether the value is a known member of the AttachmentContentType enum.
func (e AttachmentContentType) Valid() bool {
switch e {
case AttachmentContentTypeImagejpeg:
return true
case AttachmentContentTypeImagepng:
return true
default:
return false
}
}
// Defines values for AttachmentStatus.
const (
Ready AttachmentStatus = "ready"
)
// Valid indicates whether the value is a known member of the AttachmentStatus enum.
func (e AttachmentStatus) Valid() bool {
switch e {
case Ready:
return true
default:
return false
}
}
// Defines values for ErrorErrorCode.
const (
Conflict ErrorErrorCode = "conflict"
InternalError ErrorErrorCode = "internal_error"
InvalidRequest ErrorErrorCode = "invalid_request"
NotFound ErrorErrorCode = "not_found"
PayloadTooLarge ErrorErrorCode = "payload_too_large"
RateLimited ErrorErrorCode = "rate_limited"
Unauthorized ErrorErrorCode = "unauthorized"
Unavailable ErrorErrorCode = "unavailable"
UnsupportedMediaType ErrorErrorCode = "unsupported_media_type"
)
// Valid indicates whether the value is a known member of the ErrorErrorCode enum.
func (e ErrorErrorCode) Valid() bool {
switch e {
case Conflict:
return true
case InternalError:
return true
case InvalidRequest:
return true
case NotFound:
return true
case PayloadTooLarge:
return true
case RateLimited:
return true
case Unauthorized:
return true
case Unavailable:
return true
case UnsupportedMediaType:
return true
default:
return false
}
}
// Defines values for HealthStatus.
const (
Ok HealthStatus = "ok"
)
// Valid indicates whether the value is a known member of the HealthStatus enum.
func (e HealthStatus) Valid() bool {
switch e {
case Ok:
return true
default:
return false
}
}
// Defines values for SessionTokenType.
const (
Bearer SessionTokenType = "Bearer"
)
// Valid indicates whether the value is a known member of the SessionTokenType enum.
func (e SessionTokenType) Valid() bool {
switch e {
case Bearer:
return true
default:
return false
}
}
// Defines values for VariantContentType.
const (
VariantContentTypeImagejpeg VariantContentType = "image/jpeg"
VariantContentTypeImagepng VariantContentType = "image/png"
VariantContentTypeImagewebp VariantContentType = "image/webp"
)
// Valid indicates whether the value is a known member of the VariantContentType enum.
func (e VariantContentType) Valid() bool {
switch e {
case VariantContentTypeImagejpeg:
return true
case VariantContentTypeImagepng:
return true
case VariantContentTypeImagewebp:
return true
default:
return false
}
}
// Defines values for VariantName.
const (
Crop VariantName = "crop"
Optimized VariantName = "optimized"
Thumbnail VariantName = "thumbnail"
)
// Valid indicates whether the value is a known member of the VariantName enum.
func (e VariantName) Valid() bool {
switch e {
case Crop:
return true
case Optimized:
return true
case Thumbnail:
return true
default:
return false
}
}
// Defines values for DownloadAttachmentParamsVariant.
const (
Original DownloadAttachmentParamsVariant = "original"
)
// Valid indicates whether the value is a known member of the DownloadAttachmentParamsVariant enum.
func (e DownloadAttachmentParamsVariant) Valid() bool {
switch e {
case Original:
return true
default:
return false
}
}
// Attachment defines model for Attachment.
type Attachment struct {
ChatId openapi_types.UUID `json:"chat_id"`
ContentType AttachmentContentType `json:"content_type"`
CreatedAt Timestamp `json:"created_at"`
ErrorCode *string `json:"error_code"`
Filename string `json:"filename"`
Id openapi_types.UUID `json:"id"`
OwnerId openapi_types.UUID `json:"owner_id"`
Sha256 string `json:"sha256"`
SizeBytes int `json:"size_bytes"`
Status AttachmentStatus `json:"status"`
UpdatedAt Timestamp `json:"updated_at"`
Variants []Variant `json:"variants"`
}
// AttachmentContentType defines model for Attachment.ContentType.
type AttachmentContentType string
// AttachmentStatus defines model for Attachment.Status.
type AttachmentStatus string
// Chat Examples: {"created_at":"2026-09-01T12:00:00Z","id":"33333333-3333-4333-8333-333333333333","member_ids":["11111111-1111-4111-8111-111111111111","22222222-2222-4222-8222-222222222222"],"title":"Проект по ВНП"}
type Chat struct {
CreatedAt Timestamp `json:"created_at"`
Id openapi_types.UUID `json:"id"`
MemberIds []openapi_types.UUID `json:"member_ids"`
Title string `json:"title"`
}
// ChatPage defines model for ChatPage.
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// CreateChat Examples: {"member_ids":["11111111-1111-4111-8111-111111111111","22222222-2222-4222-8222-222222222222"],"title":"Проект по ВНП"}
type CreateChat struct {
MemberIds []openapi_types.UUID `json:"member_ids"`
Title string `json:"title"`
}
// CreateMessage Examples: {"text":"Привет, Боб!"}
type CreateMessage struct {
AttachmentIds *[]openapi_types.UUID `json:"attachment_ids,omitempty"`
Text string `json:"text"`
}
// CreateUser Examples: {"display_name":"Алиса","password":"Example-only-not-a-real-secret-123","username":"alice"}
type CreateUser struct {
DisplayName string `json:"display_name"`
Password *string `json:"password,omitempty"`
Username string `json:"username"`
}
// Error Examples: {"error":{"code":"not_found","message":"Объект не найден","request_id":"example-request-id"}}
type Error struct {
Error struct {
Code ErrorErrorCode `json:"code"`
Message string `json:"message"`
RequestId string `json:"request_id"`
} `json:"error"`
}
// ErrorErrorCode defines model for Error.Error.Code.
type ErrorErrorCode string
// Health defines model for Health.
type Health struct {
Status HealthStatus `json:"status"`
}
// HealthStatus defines model for Health.Status.
type HealthStatus string
// Message Examples: {"attachment_ids":[],"chat_id":"33333333-3333-4333-8333-333333333333","created_at":"2026-09-01T12:00:00Z","id":"44444444-4444-4444-8444-444444444444","sender_id":"11111111-1111-4111-8111-111111111111","text":"Привет, Боб!"}
type Message struct {
AttachmentIds []openapi_types.UUID `json:"attachment_ids"`
ChatId openapi_types.UUID `json:"chat_id"`
CreatedAt Timestamp `json:"created_at"`
Id openapi_types.UUID `json:"id"`
SenderId openapi_types.UUID `json:"sender_id"`
Text string `json:"text"`
}
// MessagePage Examples: {"items":[{"attachment_ids":[],"chat_id":"33333333-3333-4333-8333-333333333333","created_at":"2026-09-01T12:00:00Z","id":"44444444-4444-4444-8444-444444444444","sender_id":"11111111-1111-4111-8111-111111111111","text":"Привет, Боб!"}],"next_cursor":null}
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// Session defines model for Session.
type Session struct {
ExpiresAt Timestamp `json:"expires_at"`
Token string `json:"token"`
TokenType SessionTokenType `json:"token_type"`
// User Examples: {"created_at":"2026-09-01T12:00:00Z","display_name":"Алиса","id":"11111111-1111-4111-8111-111111111111","username":"alice"}
User User `json:"user"`
}
// SessionTokenType defines model for Session.TokenType.
type SessionTokenType string
// User Examples: {"created_at":"2026-09-01T12:00:00Z","display_name":"Алиса","id":"11111111-1111-4111-8111-111111111111","username":"alice"}
type User struct {
CreatedAt Timestamp `json:"created_at"`
DisplayName string `json:"display_name"`
Id openapi_types.UUID `json:"id"`
Username string `json:"username"`
}
// Variant defines model for Variant.
type Variant struct {
ContentType VariantContentType `json:"content_type"`
Height int `json:"height"`
Name VariantName `json:"name"`
Sha256 string `json:"sha256"`
SizeBytes int `json:"size_bytes"`
Width int `json:"width"`
}
// VariantContentType defines model for Variant.ContentType.
type VariantContentType string
// VariantName defines model for Variant.Name.
type VariantName string
// DownloadAttachmentParams defines parameters for DownloadAttachment.
type DownloadAttachmentParams struct {
Variant *DownloadAttachmentParamsVariant `form:"variant,omitempty" json:"variant,omitempty"`
}
// DownloadAttachmentParamsVariant defines parameters for DownloadAttachment.
type DownloadAttachmentParamsVariant string
// ListChatsParams defines parameters for ListChats.
type ListChatsParams struct {
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
}
// UploadAttachmentParams defines parameters for UploadAttachment.
type UploadAttachmentParams struct {
Filename string `form:"filename" json:"filename"`
}
// ListMessagesParams defines parameters for ListMessages.
type ListMessagesParams struct {
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
}
// CreateMessageParams defines parameters for CreateMessage.
type CreateMessageParams struct {
// IdempotencyKey Обязателен с lab3. Область: пользователь + метод + путь + ключ; хранить результат не менее 24 ч. Повтор того же JSON возвращает исходный 201 и то же сообщение, другой JSON — 409.
IdempotencyKey string `json:"Idempotency-Key"`
}
// CreateChatJSONRequestBody defines body for CreateChat for application/json ContentType.
type CreateChatJSONRequestBody = CreateChat
// CreateMessageJSONRequestBody defines body for CreateMessage for application/json ContentType.
type CreateMessageJSONRequestBody = CreateMessage
// RegisterUserJSONRequestBody defines body for RegisterUser for application/json ContentType.
type RegisterUserJSONRequestBody = CreateUser
// ServerInterface represents all server handlers.
type ServerInterface interface {
// GetAttachment Метаданные вложения, доступ участникам чата
// (GET /api/v1/attachments/{attachment_id})
GetAttachment(w http.ResponseWriter, r *http.Request, attachmentId openapi_types.UUID)
// DownloadAttachment Скачать байты через авторизованный API
// (GET /api/v1/attachments/{attachment_id}/content)
DownloadAttachment(w http.ResponseWriter, r *http.Request, attachmentId openapi_types.UUID, params DownloadAttachmentParams)
// CreateSession Вход: Basic username:password; выдаёт сессию
// (POST /api/v1/auth/sessions)
CreateSession(w http.ResponseWriter, r *http.Request)
// RevokeSession Отозвать текущую сессию
// (DELETE /api/v1/auth/sessions/current)
RevokeSession(w http.ResponseWriter, r *http.Request)
// ListChats Чаты текущего пользователя
// (GET /api/v1/chats)
ListChats(w http.ResponseWriter, r *http.Request, params ListChatsParams)
// CreateChat Создать чат; вызывающий должен входить в member_ids
// (POST /api/v1/chats)
CreateChat(w http.ResponseWriter, r *http.Request)
// GetChat Получить доступный чат
// (GET /api/v1/chats/{chat_id})
GetChat(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID)
// UploadAttachment Принять один PNG/JPEG, до 10 MiB
// (POST /api/v1/chats/{chat_id}/attachments)
UploadAttachment(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params UploadAttachmentParams)
// ListMessages Сообщения по (created_at, id) по возрастанию
// (GET /api/v1/chats/{chat_id}/messages)
ListMessages(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params ListMessagesParams)
// CreateMessage Отправить сообщение
// (POST /api/v1/chats/{chat_id}/messages)
CreateMessage(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params CreateMessageParams)
// RegisterUser Создать пользователя
// (POST /api/v1/users)
RegisterUser(w http.ResponseWriter, r *http.Request)
// CurrentUser Текущий пользователь
// (GET /api/v1/users/me)
CurrentUser(w http.ResponseWriter, r *http.Request)
// Liveness Процесс жив
// (GET /health/live)
Liveness(w http.ResponseWriter, r *http.Request)
// Readiness Готов принимать трафик
// (GET /health/ready)
Readiness(w http.ResponseWriter, r *http.Request)
}
// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.
type Unimplemented struct{}
// GetAttachment Метаданные вложения, доступ участникам чата
// (GET /api/v1/attachments/{attachment_id})
func (_ Unimplemented) GetAttachment(w http.ResponseWriter, r *http.Request, attachmentId openapi_types.UUID) {
w.WriteHeader(http.StatusNotImplemented)
}
// DownloadAttachment Скачать байты через авторизованный API
// (GET /api/v1/attachments/{attachment_id}/content)
func (_ Unimplemented) DownloadAttachment(w http.ResponseWriter, r *http.Request, attachmentId openapi_types.UUID, params DownloadAttachmentParams) {
w.WriteHeader(http.StatusNotImplemented)
}
// CreateSession Вход: Basic username:password; выдаёт сессию
// (POST /api/v1/auth/sessions)
func (_ Unimplemented) CreateSession(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// RevokeSession Отозвать текущую сессию
// (DELETE /api/v1/auth/sessions/current)
func (_ Unimplemented) RevokeSession(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// ListChats Чаты текущего пользователя
// (GET /api/v1/chats)
func (_ Unimplemented) ListChats(w http.ResponseWriter, r *http.Request, params ListChatsParams) {
w.WriteHeader(http.StatusNotImplemented)
}
// CreateChat Создать чат; вызывающий должен входить в member_ids
// (POST /api/v1/chats)
func (_ Unimplemented) CreateChat(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// GetChat Получить доступный чат
// (GET /api/v1/chats/{chat_id})
func (_ Unimplemented) GetChat(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID) {
w.WriteHeader(http.StatusNotImplemented)
}
// UploadAttachment Принять один PNG/JPEG, до 10 MiB
// (POST /api/v1/chats/{chat_id}/attachments)
func (_ Unimplemented) UploadAttachment(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params UploadAttachmentParams) {
w.WriteHeader(http.StatusNotImplemented)
}
// ListMessages Сообщения по (created_at, id) по возрастанию
// (GET /api/v1/chats/{chat_id}/messages)
func (_ Unimplemented) ListMessages(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params ListMessagesParams) {
w.WriteHeader(http.StatusNotImplemented)
}
// CreateMessage Отправить сообщение
// (POST /api/v1/chats/{chat_id}/messages)
func (_ Unimplemented) CreateMessage(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params CreateMessageParams) {
w.WriteHeader(http.StatusNotImplemented)
}
// RegisterUser Создать пользователя
// (POST /api/v1/users)
func (_ Unimplemented) RegisterUser(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// CurrentUser Текущий пользователь
// (GET /api/v1/users/me)
func (_ Unimplemented) CurrentUser(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// Liveness Процесс жив
// (GET /health/live)
func (_ Unimplemented) Liveness(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// Readiness Готов принимать трафик
// (GET /health/ready)
func (_ Unimplemented) Readiness(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotImplemented)
}
// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
Handler ServerInterface
HandlerMiddlewares []MiddlewareFunc
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}
type MiddlewareFunc func(http.Handler) http.Handler
// GetAttachment operation middleware
func (siw *ServerInterfaceWrapper) GetAttachment(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// ------------- Path parameter "attachment_id" -------------
var attachmentId openapi_types.UUID
err = runtime.BindStyledParameterWithOptions("simple", "attachment_id", chi.URLParam(r, "attachment_id"), &attachmentId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "attachment_id", Err: err})
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetAttachment(w, r, attachmentId)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// DownloadAttachment operation middleware
func (siw *ServerInterfaceWrapper) DownloadAttachment(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// ------------- Path parameter "attachment_id" -------------
var attachmentId openapi_types.UUID
err = runtime.BindStyledParameterWithOptions("simple", "attachment_id", chi.URLParam(r, "attachment_id"), &attachmentId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "attachment_id", Err: err})
return
}
// Parameter object where we will unmarshal all parameters from the context
var params DownloadAttachmentParams
// ------------- Optional query parameter "variant" -------------
err = runtime.BindQueryParameterWithOptions("form", true, false, "variant", r.URL.Query(), &params.Variant, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
if err != nil {
var requiredError *runtime.RequiredParameterError
if errors.As(err, &requiredError) {
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "variant"})
} else {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "variant", Err: err})
}
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.DownloadAttachment(w, r, attachmentId, params)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// CreateSession operation middleware
func (siw *ServerInterfaceWrapper) CreateSession(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.CreateSession(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// RevokeSession operation middleware
func (siw *ServerInterfaceWrapper) RevokeSession(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.RevokeSession(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// ListChats operation middleware
func (siw *ServerInterfaceWrapper) ListChats(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// Parameter object where we will unmarshal all parameters from the context
var params ListChatsParams
// ------------- Optional query parameter "limit" -------------
err = runtime.BindQueryParameterWithOptions("form", true, false, "limit", r.URL.Query(), &params.Limit, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
if err != nil {
var requiredError *runtime.RequiredParameterError
if errors.As(err, &requiredError) {
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "limit"})
} else {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
}
return
}
// ------------- Optional query parameter "cursor" -------------
err = runtime.BindQueryParameterWithOptions("form", true, false, "cursor", r.URL.Query(), &params.Cursor, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
if err != nil {
var requiredError *runtime.RequiredParameterError
if errors.As(err, &requiredError) {
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "cursor"})
} else {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "cursor", Err: err})
}
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.ListChats(w, r, params)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// CreateChat operation middleware
func (siw *ServerInterfaceWrapper) CreateChat(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.CreateChat(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// GetChat operation middleware
func (siw *ServerInterfaceWrapper) GetChat(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// ------------- Path parameter "chat_id" -------------
var chatId openapi_types.UUID
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.GetChat(w, r, chatId)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// UploadAttachment operation middleware
func (siw *ServerInterfaceWrapper) UploadAttachment(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// ------------- Path parameter "chat_id" -------------
var chatId openapi_types.UUID
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
return
}
// Parameter object where we will unmarshal all parameters from the context
var params UploadAttachmentParams
// ------------- Required query parameter "filename" -------------
err = runtime.BindQueryParameterWithOptions("form", true, true, "filename", r.URL.Query(), &params.Filename, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
if err != nil {
var requiredError *runtime.RequiredParameterError
if errors.As(err, &requiredError) {
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "filename"})
} else {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filename", Err: err})
}
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.UploadAttachment(w, r, chatId, params)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// ListMessages operation middleware
func (siw *ServerInterfaceWrapper) ListMessages(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// ------------- Path parameter "chat_id" -------------
var chatId openapi_types.UUID
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
return
}
// Parameter object where we will unmarshal all parameters from the context
var params ListMessagesParams
// ------------- Optional query parameter "limit" -------------
err = runtime.BindQueryParameterWithOptions("form", true, false, "limit", r.URL.Query(), &params.Limit, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
if err != nil {
var requiredError *runtime.RequiredParameterError
if errors.As(err, &requiredError) {
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "limit"})
} else {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
}
return
}
// ------------- Optional query parameter "cursor" -------------
err = runtime.BindQueryParameterWithOptions("form", true, false, "cursor", r.URL.Query(), &params.Cursor, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
if err != nil {
var requiredError *runtime.RequiredParameterError
if errors.As(err, &requiredError) {
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "cursor"})
} else {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "cursor", Err: err})
}
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.ListMessages(w, r, chatId, params)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// CreateMessage operation middleware
func (siw *ServerInterfaceWrapper) CreateMessage(w http.ResponseWriter, r *http.Request) {
var err error
_ = err
// ------------- Path parameter "chat_id" -------------
var chatId openapi_types.UUID
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
return
}
// Parameter object where we will unmarshal all parameters from the context
var params CreateMessageParams
headers := r.Header
// ------------- Required header parameter "Idempotency-Key" -------------
if valueList, found := headers[http.CanonicalHeaderKey("Idempotency-Key")]; found {
var IdempotencyKey string
n := len(valueList)
if n != 1 {
siw.ErrorHandlerFunc(w, r, &TooManyValuesForParamError{ParamName: "Idempotency-Key", Count: n})
return
}
err = runtime.BindStyledParameterWithOptions("simple", "Idempotency-Key", valueList[0], &IdempotencyKey, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationHeader, Explode: false, Required: true, Type: "string", Format: ""})
if err != nil {
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "Idempotency-Key", Err: err})
return
}
params.IdempotencyKey = IdempotencyKey
} else {
err := fmt.Errorf("Header parameter Idempotency-Key is required, but not found")
siw.ErrorHandlerFunc(w, r, &RequiredHeaderError{ParamName: "Idempotency-Key", Err: err})
return
}
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.CreateMessage(w, r, chatId, params)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// RegisterUser operation middleware
func (siw *ServerInterfaceWrapper) RegisterUser(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.RegisterUser(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// CurrentUser operation middleware
func (siw *ServerInterfaceWrapper) CurrentUser(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.CurrentUser(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// Liveness operation middleware
func (siw *ServerInterfaceWrapper) Liveness(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.Liveness(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
// Readiness operation middleware
func (siw *ServerInterfaceWrapper) Readiness(w http.ResponseWriter, r *http.Request) {
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
siw.Handler.Readiness(w, r)
}))
for _, middleware := range siw.HandlerMiddlewares {
handler = middleware(handler)
}
handler.ServeHTTP(w, r)
}
type UnescapedCookieParamError struct {
ParamName string
Err error
}
func (e *UnescapedCookieParamError) Error() string {
return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
}
func (e *UnescapedCookieParamError) Unwrap() error {
return e.Err
}
type UnmarshalingParamError struct {
ParamName string
Err error
}
func (e *UnmarshalingParamError) Error() string {
return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
}
func (e *UnmarshalingParamError) Unwrap() error {
return e.Err
}
type RequiredParamError struct {
ParamName string
}
func (e *RequiredParamError) Error() string {
return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
}
type RequiredHeaderError struct {
ParamName string
Err error
}
func (e *RequiredHeaderError) Error() string {
return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
}
func (e *RequiredHeaderError) Unwrap() error {
return e.Err
}
type InvalidParamFormatError struct {
ParamName string
Err error
}
func (e *InvalidParamFormatError) Error() string {
return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
}
func (e *InvalidParamFormatError) Unwrap() error {
return e.Err
}
type TooManyValuesForParamError struct {
ParamName string
Count int
}
func (e *TooManyValuesForParamError) Error() string {
return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
}
// Handler creates http.Handler with routing matching OpenAPI spec.
func Handler(si ServerInterface) http.Handler {
return HandlerWithOptions(si, ChiServerOptions{})
}
type ChiServerOptions struct {
BaseURL string
BaseRouter chi.Router
Middlewares []MiddlewareFunc
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}
// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler {
return HandlerWithOptions(si, ChiServerOptions{
BaseRouter: r,
})
}
func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler {
return HandlerWithOptions(si, ChiServerOptions{
BaseURL: baseURL,
BaseRouter: r,
})
}
// HandlerWithOptions creates http.Handler with additional options
func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handler {
r := options.BaseRouter
if r == nil {
r = chi.NewRouter()
}
if options.ErrorHandlerFunc == nil {
options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
http.Error(w, err.Error(), http.StatusBadRequest)
}
}
wrapper := ServerInterfaceWrapper{
Handler: si,
HandlerMiddlewares: options.Middlewares,
ErrorHandlerFunc: options.ErrorHandlerFunc,
}
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/api/v1/attachments/{attachment_id}", wrapper.GetAttachment)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/api/v1/attachments/{attachment_id}/content", wrapper.DownloadAttachment)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/api/v1/auth/sessions", wrapper.CreateSession)
})
r.Group(func(r chi.Router) {
r.Delete(options.BaseURL+"/api/v1/auth/sessions/current", wrapper.RevokeSession)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/api/v1/chats", wrapper.ListChats)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/api/v1/chats", wrapper.CreateChat)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/api/v1/chats/{chat_id}", wrapper.GetChat)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/api/v1/chats/{chat_id}/attachments", wrapper.UploadAttachment)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/api/v1/chats/{chat_id}/messages", wrapper.ListMessages)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/api/v1/chats/{chat_id}/messages", wrapper.CreateMessage)
})
r.Group(func(r chi.Router) {
r.Post(options.BaseURL+"/api/v1/users", wrapper.RegisterUser)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/api/v1/users/me", wrapper.CurrentUser)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/health/live", wrapper.Liveness)
})
r.Group(func(r chi.Router) {
r.Get(options.BaseURL+"/health/ready", wrapper.Readiness)
})
return r
}
type GetAttachmentRequestObject struct {
AttachmentId openapi_types.UUID `json:"attachment_id"`
}
type GetAttachmentResponseObject interface {
VisitGetAttachmentResponse(w http.ResponseWriter) error
}
type GetAttachment200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetAttachment200JSONResponse struct {
Body Attachment
Headers GetAttachment200ResponseHeaders
}
func (response GetAttachment200JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetAttachment400JSONResponse struct {
Body Error
Headers GetAttachment400ResponseHeaders
}
func (response GetAttachment400JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type GetAttachment401JSONResponse struct {
Body Error
Headers GetAttachment401ResponseHeaders
}
func (response GetAttachment401JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetAttachment404JSONResponse struct {
Body Error
Headers GetAttachment404ResponseHeaders
}
func (response GetAttachment404JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetAttachment409JSONResponse struct {
Body Error
Headers GetAttachment409ResponseHeaders
}
func (response GetAttachment409JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type GetAttachment429JSONResponse struct {
Body Error
Headers GetAttachment429ResponseHeaders
}
func (response GetAttachment429JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetAttachment500JSONResponse struct {
Body Error
Headers GetAttachment500ResponseHeaders
}
func (response GetAttachment500JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type GetAttachment503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetAttachment503JSONResponse struct {
Body Error
Headers GetAttachment503ResponseHeaders
}
func (response GetAttachment503JSONResponse) VisitGetAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachmentRequestObject struct {
AttachmentId openapi_types.UUID `json:"attachment_id"`
Params DownloadAttachmentParams
}
type DownloadAttachmentResponseObject interface {
VisitDownloadAttachmentResponse(w http.ResponseWriter) error
}
type DownloadAttachment200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type DownloadAttachment200ImagejpegResponse struct {
Body io.Reader
Headers DownloadAttachment200ResponseHeaders
ContentLength int64
}
func (response DownloadAttachment200ImagejpegResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "image/jpeg")
if response.ContentLength != 0 {
w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
if closer, ok := response.Body.(io.ReadCloser); ok {
defer closer.Close()
}
_, err := io.Copy(w, response.Body)
return err
}
type DownloadAttachment200ImagepngResponse struct {
Body io.Reader
Headers DownloadAttachment200ResponseHeaders
ContentLength int64
}
func (response DownloadAttachment200ImagepngResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "image/png")
if response.ContentLength != 0 {
w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
if closer, ok := response.Body.(io.ReadCloser); ok {
defer closer.Close()
}
_, err := io.Copy(w, response.Body)
return err
}
type DownloadAttachment200ImagewebpResponse struct {
Body io.Reader
Headers DownloadAttachment200ResponseHeaders
ContentLength int64
}
func (response DownloadAttachment200ImagewebpResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "image/webp")
if response.ContentLength != 0 {
w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
if closer, ok := response.Body.(io.ReadCloser); ok {
defer closer.Close()
}
_, err := io.Copy(w, response.Body)
return err
}
type DownloadAttachment400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type DownloadAttachment400JSONResponse struct {
Body Error
Headers DownloadAttachment400ResponseHeaders
}
func (response DownloadAttachment400JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachment401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type DownloadAttachment401JSONResponse struct {
Body Error
Headers DownloadAttachment401ResponseHeaders
}
func (response DownloadAttachment401JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachment404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type DownloadAttachment404JSONResponse struct {
Body Error
Headers DownloadAttachment404ResponseHeaders
}
func (response DownloadAttachment404JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachment409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type DownloadAttachment409JSONResponse struct {
Body Error
Headers DownloadAttachment409ResponseHeaders
}
func (response DownloadAttachment409JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachment429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type DownloadAttachment429JSONResponse struct {
Body Error
Headers DownloadAttachment429ResponseHeaders
}
func (response DownloadAttachment429JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachment500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type DownloadAttachment500JSONResponse struct {
Body Error
Headers DownloadAttachment500ResponseHeaders
}
func (response DownloadAttachment500JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type DownloadAttachment503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type DownloadAttachment503JSONResponse struct {
Body Error
Headers DownloadAttachment503ResponseHeaders
}
func (response DownloadAttachment503JSONResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type CreateSessionRequestObject struct {
}
type CreateSessionResponseObject interface {
VisitCreateSessionResponse(w http.ResponseWriter) error
}
type CreateSession201ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateSession201JSONResponse struct {
Body Session
Headers CreateSession201ResponseHeaders
}
func (response CreateSession201JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(201)
_, err := buf.WriteTo(w)
return err
}
type CreateSession400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateSession400JSONResponse struct {
Body Error
Headers CreateSession400ResponseHeaders
}
func (response CreateSession400JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type CreateSession401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type CreateSession401JSONResponse struct {
Body Error
Headers CreateSession401ResponseHeaders
}
func (response CreateSession401JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type CreateSession429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type CreateSession429JSONResponse struct {
Body Error
Headers CreateSession429ResponseHeaders
}
func (response CreateSession429JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type CreateSession500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateSession500JSONResponse struct {
Body Error
Headers CreateSession500ResponseHeaders
}
func (response CreateSession500JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type CreateSession503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateSession503JSONResponse struct {
Body Error
Headers CreateSession503ResponseHeaders
}
func (response CreateSession503JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type RevokeSessionRequestObject struct {
}
type RevokeSessionResponseObject interface {
VisitRevokeSessionResponse(w http.ResponseWriter) error
}
type RevokeSession204ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RevokeSession204Response struct {
Headers RevokeSession204ResponseHeaders
}
func (response RevokeSession204Response) VisitRevokeSessionResponse(w http.ResponseWriter) error {
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(204)
return nil
}
type RevokeSession401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type RevokeSession401JSONResponse struct {
Body Error
Headers RevokeSession401ResponseHeaders
}
func (response RevokeSession401JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type RevokeSession429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type RevokeSession429JSONResponse struct {
Body Error
Headers RevokeSession429ResponseHeaders
}
func (response RevokeSession429JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type RevokeSession500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RevokeSession500JSONResponse struct {
Body Error
Headers RevokeSession500ResponseHeaders
}
func (response RevokeSession500JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type RevokeSession503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RevokeSession503JSONResponse struct {
Body Error
Headers RevokeSession503ResponseHeaders
}
func (response RevokeSession503JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type ListChatsRequestObject struct {
Params ListChatsParams
}
type ListChatsResponseObject interface {
VisitListChatsResponse(w http.ResponseWriter) error
}
type ListChats200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListChats200JSONResponse struct {
Body ChatPage
Headers ListChats200ResponseHeaders
}
func (response ListChats200JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type ListChats400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListChats400JSONResponse struct {
Body Error
Headers ListChats400ResponseHeaders
}
func (response ListChats400JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type ListChats401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type ListChats401JSONResponse struct {
Body Error
Headers ListChats401ResponseHeaders
}
func (response ListChats401JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type ListChats404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListChats404JSONResponse struct {
Body Error
Headers ListChats404ResponseHeaders
}
func (response ListChats404JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type ListChats409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListChats409JSONResponse struct {
Body Error
Headers ListChats409ResponseHeaders
}
func (response ListChats409JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type ListChats429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type ListChats429JSONResponse struct {
Body Error
Headers ListChats429ResponseHeaders
}
func (response ListChats429JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type ListChats500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListChats500JSONResponse struct {
Body Error
Headers ListChats500ResponseHeaders
}
func (response ListChats500JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type ListChats503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListChats503JSONResponse struct {
Body Error
Headers ListChats503ResponseHeaders
}
func (response ListChats503JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type CreateChatRequestObject struct {
Body *CreateChatJSONRequestBody
}
type CreateChatResponseObject interface {
VisitCreateChatResponse(w http.ResponseWriter) error
}
type CreateChat201ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateChat201JSONResponse struct {
Body Chat
Headers CreateChat201ResponseHeaders
}
func (response CreateChat201JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(201)
_, err := buf.WriteTo(w)
return err
}
type CreateChat400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateChat400JSONResponse struct {
Body Error
Headers CreateChat400ResponseHeaders
}
func (response CreateChat400JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type CreateChat401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type CreateChat401JSONResponse struct {
Body Error
Headers CreateChat401ResponseHeaders
}
func (response CreateChat401JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type CreateChat404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateChat404JSONResponse struct {
Body Error
Headers CreateChat404ResponseHeaders
}
func (response CreateChat404JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type CreateChat409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateChat409JSONResponse struct {
Body Error
Headers CreateChat409ResponseHeaders
}
func (response CreateChat409JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type CreateChat429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type CreateChat429JSONResponse struct {
Body Error
Headers CreateChat429ResponseHeaders
}
func (response CreateChat429JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type CreateChat500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateChat500JSONResponse struct {
Body Error
Headers CreateChat500ResponseHeaders
}
func (response CreateChat500JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type CreateChat503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateChat503JSONResponse struct {
Body Error
Headers CreateChat503ResponseHeaders
}
func (response CreateChat503JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type GetChatRequestObject struct {
ChatId openapi_types.UUID `json:"chat_id"`
}
type GetChatResponseObject interface {
VisitGetChatResponse(w http.ResponseWriter) error
}
type GetChat200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetChat200JSONResponse struct {
Body Chat
Headers GetChat200ResponseHeaders
}
func (response GetChat200JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type GetChat400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetChat400JSONResponse struct {
Body Error
Headers GetChat400ResponseHeaders
}
func (response GetChat400JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type GetChat401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type GetChat401JSONResponse struct {
Body Error
Headers GetChat401ResponseHeaders
}
func (response GetChat401JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type GetChat404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetChat404JSONResponse struct {
Body Error
Headers GetChat404ResponseHeaders
}
func (response GetChat404JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type GetChat409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetChat409JSONResponse struct {
Body Error
Headers GetChat409ResponseHeaders
}
func (response GetChat409JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type GetChat429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type GetChat429JSONResponse struct {
Body Error
Headers GetChat429ResponseHeaders
}
func (response GetChat429JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type GetChat500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetChat500JSONResponse struct {
Body Error
Headers GetChat500ResponseHeaders
}
func (response GetChat500JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type GetChat503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type GetChat503JSONResponse struct {
Body Error
Headers GetChat503ResponseHeaders
}
func (response GetChat503JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachmentRequestObject struct {
ChatId openapi_types.UUID `json:"chat_id"`
Params UploadAttachmentParams
Body io.Reader
}
type UploadAttachmentResponseObject interface {
VisitUploadAttachmentResponse(w http.ResponseWriter) error
}
type UploadAttachment201ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment201JSONResponse struct {
Body Attachment
Headers UploadAttachment201ResponseHeaders
}
func (response UploadAttachment201JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(201)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment400JSONResponse struct {
Body Error
Headers UploadAttachment400ResponseHeaders
}
func (response UploadAttachment400JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type UploadAttachment401JSONResponse struct {
Body Error
Headers UploadAttachment401ResponseHeaders
}
func (response UploadAttachment401JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment404JSONResponse struct {
Body Error
Headers UploadAttachment404ResponseHeaders
}
func (response UploadAttachment404JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment413ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment413JSONResponse struct {
Body Error
Headers UploadAttachment413ResponseHeaders
}
func (response UploadAttachment413JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(413)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment415ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment415JSONResponse struct {
Body Error
Headers UploadAttachment415ResponseHeaders
}
func (response UploadAttachment415JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(415)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type UploadAttachment429JSONResponse struct {
Body Error
Headers UploadAttachment429ResponseHeaders
}
func (response UploadAttachment429JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment500JSONResponse struct {
Body Error
Headers UploadAttachment500ResponseHeaders
}
func (response UploadAttachment500JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type UploadAttachment503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type UploadAttachment503JSONResponse struct {
Body Error
Headers UploadAttachment503ResponseHeaders
}
func (response UploadAttachment503JSONResponse) VisitUploadAttachmentResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type ListMessagesRequestObject struct {
ChatId openapi_types.UUID `json:"chat_id"`
Params ListMessagesParams
}
type ListMessagesResponseObject interface {
VisitListMessagesResponse(w http.ResponseWriter) error
}
type ListMessages200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListMessages200JSONResponse struct {
Body MessagePage
Headers ListMessages200ResponseHeaders
}
func (response ListMessages200JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type ListMessages400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListMessages400JSONResponse struct {
Body Error
Headers ListMessages400ResponseHeaders
}
func (response ListMessages400JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type ListMessages401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type ListMessages401JSONResponse struct {
Body Error
Headers ListMessages401ResponseHeaders
}
func (response ListMessages401JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type ListMessages404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListMessages404JSONResponse struct {
Body Error
Headers ListMessages404ResponseHeaders
}
func (response ListMessages404JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type ListMessages409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListMessages409JSONResponse struct {
Body Error
Headers ListMessages409ResponseHeaders
}
func (response ListMessages409JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type ListMessages429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type ListMessages429JSONResponse struct {
Body Error
Headers ListMessages429ResponseHeaders
}
func (response ListMessages429JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type ListMessages500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListMessages500JSONResponse struct {
Body Error
Headers ListMessages500ResponseHeaders
}
func (response ListMessages500JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type ListMessages503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type ListMessages503JSONResponse struct {
Body Error
Headers ListMessages503ResponseHeaders
}
func (response ListMessages503JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type CreateMessageRequestObject struct {
ChatId openapi_types.UUID `json:"chat_id"`
Params CreateMessageParams
Body *CreateMessageJSONRequestBody
}
type CreateMessageResponseObject interface {
VisitCreateMessageResponse(w http.ResponseWriter) error
}
type CreateMessage201ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateMessage201JSONResponse struct {
Body Message
Headers CreateMessage201ResponseHeaders
}
func (response CreateMessage201JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(201)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateMessage400JSONResponse struct {
Body Error
Headers CreateMessage400ResponseHeaders
}
func (response CreateMessage400JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type CreateMessage401JSONResponse struct {
Body Error
Headers CreateMessage401ResponseHeaders
}
func (response CreateMessage401JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateMessage404JSONResponse struct {
Body Error
Headers CreateMessage404ResponseHeaders
}
func (response CreateMessage404JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateMessage409JSONResponse struct {
Body Error
Headers CreateMessage409ResponseHeaders
}
func (response CreateMessage409JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type CreateMessage429JSONResponse struct {
Body Error
Headers CreateMessage429ResponseHeaders
}
func (response CreateMessage429JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateMessage500JSONResponse struct {
Body Error
Headers CreateMessage500ResponseHeaders
}
func (response CreateMessage500JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type CreateMessage503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CreateMessage503JSONResponse struct {
Body Error
Headers CreateMessage503ResponseHeaders
}
func (response CreateMessage503JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type RegisterUserRequestObject struct {
Body *RegisterUserJSONRequestBody
}
type RegisterUserResponseObject interface {
VisitRegisterUserResponse(w http.ResponseWriter) error
}
type RegisterUser201ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RegisterUser201JSONResponse struct {
Body User
Headers RegisterUser201ResponseHeaders
}
func (response RegisterUser201JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(201)
_, err := buf.WriteTo(w)
return err
}
type RegisterUser400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RegisterUser400JSONResponse struct {
Body Error
Headers RegisterUser400ResponseHeaders
}
func (response RegisterUser400JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type RegisterUser409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RegisterUser409JSONResponse struct {
Body Error
Headers RegisterUser409ResponseHeaders
}
func (response RegisterUser409JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type RegisterUser429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type RegisterUser429JSONResponse struct {
Body Error
Headers RegisterUser429ResponseHeaders
}
func (response RegisterUser429JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type RegisterUser500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RegisterUser500JSONResponse struct {
Body Error
Headers RegisterUser500ResponseHeaders
}
func (response RegisterUser500JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type RegisterUser503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type RegisterUser503JSONResponse struct {
Body Error
Headers RegisterUser503ResponseHeaders
}
func (response RegisterUser503JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type CurrentUserRequestObject struct {
}
type CurrentUserResponseObject interface {
VisitCurrentUserResponse(w http.ResponseWriter) error
}
type CurrentUser200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CurrentUser200JSONResponse struct {
Body User
Headers CurrentUser200ResponseHeaders
}
func (response CurrentUser200JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser400ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CurrentUser400JSONResponse struct {
Body Error
Headers CurrentUser400ResponseHeaders
}
func (response CurrentUser400JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(400)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser401ResponseHeaders struct {
WWWAuthenticate *string
XInstanceId *string
XRequestId *string
}
type CurrentUser401JSONResponse struct {
Body Error
Headers CurrentUser401ResponseHeaders
}
func (response CurrentUser401JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.WWWAuthenticate != nil {
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(401)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser404ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CurrentUser404JSONResponse struct {
Body Error
Headers CurrentUser404ResponseHeaders
}
func (response CurrentUser404JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(404)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser409ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CurrentUser409JSONResponse struct {
Body Error
Headers CurrentUser409ResponseHeaders
}
func (response CurrentUser409JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(409)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser429ResponseHeaders struct {
RetryAfter *int
XInstanceId *string
XRequestId *string
}
type CurrentUser429JSONResponse struct {
Body Error
Headers CurrentUser429ResponseHeaders
}
func (response CurrentUser429JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.RetryAfter != nil {
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
}
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(429)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CurrentUser500JSONResponse struct {
Body Error
Headers CurrentUser500ResponseHeaders
}
func (response CurrentUser500JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type CurrentUser503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type CurrentUser503JSONResponse struct {
Body Error
Headers CurrentUser503ResponseHeaders
}
func (response CurrentUser503JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
type LivenessRequestObject struct {
}
type LivenessResponseObject interface {
VisitLivenessResponse(w http.ResponseWriter) error
}
type Liveness200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type Liveness200JSONResponse struct {
Body Health
Headers Liveness200ResponseHeaders
}
func (response Liveness200JSONResponse) VisitLivenessResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type Liveness500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type Liveness500JSONResponse struct {
Body Error
Headers Liveness500ResponseHeaders
}
func (response Liveness500JSONResponse) VisitLivenessResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type ReadinessRequestObject struct {
}
type ReadinessResponseObject interface {
VisitReadinessResponse(w http.ResponseWriter) error
}
type Readiness200ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type Readiness200JSONResponse struct {
Body Health
Headers Readiness200ResponseHeaders
}
func (response Readiness200JSONResponse) VisitReadinessResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(200)
_, err := buf.WriteTo(w)
return err
}
type Readiness500ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type Readiness500JSONResponse struct {
Body Error
Headers Readiness500ResponseHeaders
}
func (response Readiness500JSONResponse) VisitReadinessResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(500)
_, err := buf.WriteTo(w)
return err
}
type Readiness503ResponseHeaders struct {
XInstanceId *string
XRequestId *string
}
type Readiness503JSONResponse struct {
Body Error
Headers Readiness503ResponseHeaders
}
func (response Readiness503JSONResponse) VisitReadinessResponse(w http.ResponseWriter) error {
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if response.Headers.XInstanceId != nil {
w.Header().Set("X-Instance-Id", fmt.Sprint(*response.Headers.XInstanceId))
}
if response.Headers.XRequestId != nil {
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
}
w.WriteHeader(503)
_, err := buf.WriteTo(w)
return err
}
// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
// GetAttachment Метаданные вложения, доступ участникам чата
// (GET /api/v1/attachments/{attachment_id})
GetAttachment(ctx context.Context, request GetAttachmentRequestObject) (GetAttachmentResponseObject, error)
// DownloadAttachment Скачать байты через авторизованный API
// (GET /api/v1/attachments/{attachment_id}/content)
DownloadAttachment(ctx context.Context, request DownloadAttachmentRequestObject) (DownloadAttachmentResponseObject, error)
// CreateSession Вход: Basic username:password; выдаёт сессию
// (POST /api/v1/auth/sessions)
CreateSession(ctx context.Context, request CreateSessionRequestObject) (CreateSessionResponseObject, error)
// RevokeSession Отозвать текущую сессию
// (DELETE /api/v1/auth/sessions/current)
RevokeSession(ctx context.Context, request RevokeSessionRequestObject) (RevokeSessionResponseObject, error)
// ListChats Чаты текущего пользователя
// (GET /api/v1/chats)
ListChats(ctx context.Context, request ListChatsRequestObject) (ListChatsResponseObject, error)
// CreateChat Создать чат; вызывающий должен входить в member_ids
// (POST /api/v1/chats)
CreateChat(ctx context.Context, request CreateChatRequestObject) (CreateChatResponseObject, error)
// GetChat Получить доступный чат
// (GET /api/v1/chats/{chat_id})
GetChat(ctx context.Context, request GetChatRequestObject) (GetChatResponseObject, error)
// UploadAttachment Принять один PNG/JPEG, до 10 MiB
// (POST /api/v1/chats/{chat_id}/attachments)
UploadAttachment(ctx context.Context, request UploadAttachmentRequestObject) (UploadAttachmentResponseObject, error)
// ListMessages Сообщения по (created_at, id) по возрастанию
// (GET /api/v1/chats/{chat_id}/messages)
ListMessages(ctx context.Context, request ListMessagesRequestObject) (ListMessagesResponseObject, error)
// CreateMessage Отправить сообщение
// (POST /api/v1/chats/{chat_id}/messages)
CreateMessage(ctx context.Context, request CreateMessageRequestObject) (CreateMessageResponseObject, error)
// RegisterUser Создать пользователя
// (POST /api/v1/users)
RegisterUser(ctx context.Context, request RegisterUserRequestObject) (RegisterUserResponseObject, error)
// CurrentUser Текущий пользователь
// (GET /api/v1/users/me)
CurrentUser(ctx context.Context, request CurrentUserRequestObject) (CurrentUserResponseObject, error)
// Liveness Процесс жив
// (GET /health/live)
Liveness(ctx context.Context, request LivenessRequestObject) (LivenessResponseObject, error)
// Readiness Готов принимать трафик
// (GET /health/ready)
Readiness(ctx context.Context, request ReadinessRequestObject) (ReadinessResponseObject, error)
}
type StrictHandlerFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, request any) (any, error)
type StrictMiddlewareFunc func(f StrictHandlerFunc, operationID string) StrictHandlerFunc
type StrictHTTPServerOptions struct {
RequestErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}
func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
return &strictHandler{ssi: ssi, middlewares: middlewares, options: StrictHTTPServerOptions{
RequestErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
http.Error(w, err.Error(), http.StatusBadRequest)
},
ResponseErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
http.Error(w, err.Error(), http.StatusInternalServerError)
},
}}
}
func NewStrictHandlerWithOptions(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc, options StrictHTTPServerOptions) ServerInterface {
if options.RequestErrorHandlerFunc == nil {
options.RequestErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
http.Error(w, err.Error(), http.StatusBadRequest)
}
}
if options.ResponseErrorHandlerFunc == nil {
options.ResponseErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
}
type strictHandler struct {
ssi StrictServerInterface
middlewares []StrictMiddlewareFunc
options StrictHTTPServerOptions
}
// GetAttachment operation middleware
func (sh *strictHandler) GetAttachment(w http.ResponseWriter, r *http.Request, attachmentId openapi_types.UUID) {
var request GetAttachmentRequestObject
request.AttachmentId = attachmentId
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.GetAttachment(ctx, request.(GetAttachmentRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "GetAttachment")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(GetAttachmentResponseObject); ok {
if err := validResponse.VisitGetAttachmentResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// DownloadAttachment operation middleware
func (sh *strictHandler) DownloadAttachment(w http.ResponseWriter, r *http.Request, attachmentId openapi_types.UUID, params DownloadAttachmentParams) {
var request DownloadAttachmentRequestObject
request.AttachmentId = attachmentId
request.Params = params
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.DownloadAttachment(ctx, request.(DownloadAttachmentRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "DownloadAttachment")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(DownloadAttachmentResponseObject); ok {
if err := validResponse.VisitDownloadAttachmentResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// CreateSession operation middleware
func (sh *strictHandler) CreateSession(w http.ResponseWriter, r *http.Request) {
var request CreateSessionRequestObject
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.CreateSession(ctx, request.(CreateSessionRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "CreateSession")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(CreateSessionResponseObject); ok {
if err := validResponse.VisitCreateSessionResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// RevokeSession operation middleware
func (sh *strictHandler) RevokeSession(w http.ResponseWriter, r *http.Request) {
var request RevokeSessionRequestObject
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.RevokeSession(ctx, request.(RevokeSessionRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "RevokeSession")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(RevokeSessionResponseObject); ok {
if err := validResponse.VisitRevokeSessionResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// ListChats operation middleware
func (sh *strictHandler) ListChats(w http.ResponseWriter, r *http.Request, params ListChatsParams) {
var request ListChatsRequestObject
request.Params = params
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.ListChats(ctx, request.(ListChatsRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "ListChats")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(ListChatsResponseObject); ok {
if err := validResponse.VisitListChatsResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// CreateChat operation middleware
func (sh *strictHandler) CreateChat(w http.ResponseWriter, r *http.Request) {
var request CreateChatRequestObject
var body CreateChatJSONRequestBody
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
return
}
request.Body = &body
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.CreateChat(ctx, request.(CreateChatRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "CreateChat")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(CreateChatResponseObject); ok {
if err := validResponse.VisitCreateChatResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// GetChat operation middleware
func (sh *strictHandler) GetChat(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID) {
var request GetChatRequestObject
request.ChatId = chatId
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.GetChat(ctx, request.(GetChatRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "GetChat")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(GetChatResponseObject); ok {
if err := validResponse.VisitGetChatResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// UploadAttachment operation middleware
func (sh *strictHandler) UploadAttachment(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params UploadAttachmentParams) {
var request UploadAttachmentRequestObject
request.ChatId = chatId
request.Params = params
request.Body = r.Body
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.UploadAttachment(ctx, request.(UploadAttachmentRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "UploadAttachment")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(UploadAttachmentResponseObject); ok {
if err := validResponse.VisitUploadAttachmentResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// ListMessages operation middleware
func (sh *strictHandler) ListMessages(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params ListMessagesParams) {
var request ListMessagesRequestObject
request.ChatId = chatId
request.Params = params
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.ListMessages(ctx, request.(ListMessagesRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "ListMessages")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(ListMessagesResponseObject); ok {
if err := validResponse.VisitListMessagesResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// CreateMessage operation middleware
func (sh *strictHandler) CreateMessage(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params CreateMessageParams) {
var request CreateMessageRequestObject
request.ChatId = chatId
request.Params = params
var body CreateMessageJSONRequestBody
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
return
}
request.Body = &body
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.CreateMessage(ctx, request.(CreateMessageRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "CreateMessage")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(CreateMessageResponseObject); ok {
if err := validResponse.VisitCreateMessageResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// RegisterUser operation middleware
func (sh *strictHandler) RegisterUser(w http.ResponseWriter, r *http.Request) {
var request RegisterUserRequestObject
var body RegisterUserJSONRequestBody
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
return
}
request.Body = &body
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.RegisterUser(ctx, request.(RegisterUserRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "RegisterUser")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(RegisterUserResponseObject); ok {
if err := validResponse.VisitRegisterUserResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// CurrentUser operation middleware
func (sh *strictHandler) CurrentUser(w http.ResponseWriter, r *http.Request) {
var request CurrentUserRequestObject
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.CurrentUser(ctx, request.(CurrentUserRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "CurrentUser")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(CurrentUserResponseObject); ok {
if err := validResponse.VisitCurrentUserResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// Liveness operation middleware
func (sh *strictHandler) Liveness(w http.ResponseWriter, r *http.Request) {
var request LivenessRequestObject
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.Liveness(ctx, request.(LivenessRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "Liveness")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(LivenessResponseObject); ok {
if err := validResponse.VisitLivenessResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}
// Readiness operation middleware
func (sh *strictHandler) Readiness(w http.ResponseWriter, r *http.Request) {
var request ReadinessRequestObject
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
return sh.ssi.Readiness(ctx, request.(ReadinessRequestObject))
}
for _, middleware := range sh.middlewares {
handler = middleware(handler, "Readiness")
}
response, err := handler(r.Context(), w, r, request)
if err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
} else if validResponse, ok := response.(ReadinessResponseObject); ok {
if err := validResponse.VisitReadinessResponse(w); err != nil {
sh.options.ResponseErrorHandlerFunc(w, r, err)
}
} else if response != nil {
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
}
}