forked from mtusi2026/mtusi2026lab4
4414 lines
130 KiB
Go
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(), ¶ms.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(), ¶ms.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(), ¶ms.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(), ¶ms.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(), ¶ms.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(), ¶ms.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))
|
|
}
|
|
}
|