byre/internal/api/api.gen.go

//go:build go1.22

// Package api 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 api

import (
	"bytes"
	"compress/flate"
	"encoding/base64"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"path"
	"strings"
	"time"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/oapi-codegen/runtime"
)

// Defines values for AgentSessionRole.
const (
	Implementer AgentSessionRole = "implementer"
)

// Valid indicates whether the value is a known member of the AgentSessionRole enum.
func (e AgentSessionRole) Valid() bool {
	switch e {
	case Implementer:
		return true
	default:
		return false
	}
}

// Defines values for AgentSessionState.
const (
	AgentSessionStateCompleted AgentSessionState = "completed"
	AgentSessionStateIdle      AgentSessionState = "idle"
	AgentSessionStateQueued    AgentSessionState = "queued"
	AgentSessionStateRunning   AgentSessionState = "running"
)

// Valid indicates whether the value is a known member of the AgentSessionState enum.
func (e AgentSessionState) Valid() bool {
	switch e {
	case AgentSessionStateCompleted:
		return true
	case AgentSessionStateIdle:
		return true
	case AgentSessionStateQueued:
		return true
	case AgentSessionStateRunning:
		return true
	default:
		return false
	}
}

// Defines values for AgentSessionVendor.
const (
	Claude AgentSessionVendor = "claude"
)

// Valid indicates whether the value is a known member of the AgentSessionVendor enum.
func (e AgentSessionVendor) Valid() bool {
	switch e {
	case Claude:
		return true
	default:
		return false
	}
}

// Defines values for AttachmentKind.
const (
	AttachmentKindDiagram  AttachmentKind = "diagram"
	AttachmentKindDiff     AttachmentKind = "diff"
	AttachmentKindFile     AttachmentKind = "file"
	AttachmentKindImage    AttachmentKind = "image"
	AttachmentKindSnapshot AttachmentKind = "snapshot"
	AttachmentKindTask     AttachmentKind = "task"
	AttachmentKindUrl      AttachmentKind = "url"
)

// Valid indicates whether the value is a known member of the AttachmentKind enum.
func (e AttachmentKind) Valid() bool {
	switch e {
	case AttachmentKindDiagram:
		return true
	case AttachmentKindDiff:
		return true
	case AttachmentKindFile:
		return true
	case AttachmentKindImage:
		return true
	case AttachmentKindSnapshot:
		return true
	case AttachmentKindTask:
		return true
	case AttachmentKindUrl:
		return true
	default:
		return false
	}
}

// Defines values for FileChangeStatus.
const (
	Added       FileChangeStatus = "added"
	Deleted     FileChangeStatus = "deleted"
	Modified    FileChangeStatus = "modified"
	Renamed     FileChangeStatus = "renamed"
	TypeChanged FileChangeStatus = "type_changed"
)

// Valid indicates whether the value is a known member of the FileChangeStatus enum.
func (e FileChangeStatus) Valid() bool {
	switch e {
	case Added:
		return true
	case Deleted:
		return true
	case Modified:
		return true
	case Renamed:
		return true
	case TypeChanged:
		return true
	default:
		return false
	}
}

// Defines values for InboxItemKind.
const (
	Question     InboxItemKind = "question"
	RateLimited  InboxItemKind = "rate_limited"
	Report       InboxItemKind = "report"
	SessionError InboxItemKind = "session_error"
)

// Valid indicates whether the value is a known member of the InboxItemKind enum.
func (e InboxItemKind) Valid() bool {
	switch e {
	case Question:
		return true
	case RateLimited:
		return true
	case Report:
		return true
	case SessionError:
		return true
	default:
		return false
	}
}

// Defines values for InboxItemPriority.
const (
	Blocked InboxItemPriority = "blocked"
	Fyi     InboxItemPriority = "fyi"
	Gate    InboxItemPriority = "gate"
	Review  InboxItemPriority = "review"
)

// Valid indicates whether the value is a known member of the InboxItemPriority enum.
func (e InboxItemPriority) Valid() bool {
	switch e {
	case Blocked:
		return true
	case Fyi:
		return true
	case Gate:
		return true
	case Review:
		return true
	default:
		return false
	}
}

// Defines values for InboxResponseType.
const (
	Dismiss InboxResponseType = "dismiss"
	Option  InboxResponseType = "option"
	Other   InboxResponseType = "other"
	Snooze  InboxResponseType = "snooze"
)

// Valid indicates whether the value is a known member of the InboxResponseType enum.
func (e InboxResponseType) Valid() bool {
	switch e {
	case Dismiss:
		return true
	case Option:
		return true
	case Other:
		return true
	case Snooze:
		return true
	default:
		return false
	}
}

// Defines values for InboxState.
const (
	Answered   InboxState = "answered"
	Dismissed  InboxState = "dismissed"
	Open       InboxState = "open"
	Superseded InboxState = "superseded"
)

// Valid indicates whether the value is a known member of the InboxState enum.
func (e InboxState) Valid() bool {
	switch e {
	case Answered:
		return true
	case Dismissed:
		return true
	case Open:
		return true
	case Superseded:
		return true
	default:
		return false
	}
}

// Defines values for TaskStatus.
const (
	TaskStatusActive    TaskStatus = "active"
	TaskStatusDiscarded TaskStatus = "discarded"
	TaskStatusMerged    TaskStatus = "merged"
)

// Valid indicates whether the value is a known member of the TaskStatus enum.
func (e TaskStatus) Valid() bool {
	switch e {
	case TaskStatusActive:
		return true
	case TaskStatusDiscarded:
		return true
	case TaskStatusMerged:
		return true
	default:
		return false
	}
}

// AgentSession defines model for AgentSession.
type AgentSession struct {
	CreatedAt time.Time `json:"created_at"`
	CreatedBy string    `json:"created_by"`
	Id        string    `json:"id"`

	// Model Requested model; empty means the vendor's default.
	Model string           `json:"model"`
	Role  AgentSessionRole `json:"role"`

	// State queued means a turn is waiting for a free slot under the concurrency caps.
	State           AgentSessionState  `json:"state"`
	TaskId          string             `json:"task_id"`
	Vendor          AgentSessionVendor `json:"vendor"`
	VendorSessionId string             `json:"vendor_session_id"`
}

// AgentSessionRole defines model for AgentSession.Role.
type AgentSessionRole string

// AgentSessionState queued means a turn is waiting for a free slot under the concurrency caps.
type AgentSessionState string

// AgentSessionVendor defines model for AgentSession.Vendor.
type AgentSessionVendor string

// Attachment defines model for Attachment.
type Attachment struct {
	Caption *string `json:"caption,omitempty"`
	EndLine *int    `json:"end_line,omitempty"`

	// Image image: data URL.
	Image *string        `json:"image,omitempty"`
	Kind  AttachmentKind `json:"kind"`

	// Mermaid diagram: Mermaid source.
	Mermaid *string `json:"mermaid,omitempty"`

	// Path file: repo-relative path.
	Path *string `json:"path,omitempty"`

	// Ref diff: git revision range.
	Ref        *string `json:"ref,omitempty"`
	SnapshotId *string `json:"snapshot_id,omitempty"`
	StartLine  *int    `json:"start_line,omitempty"`
	TaskId     *string `json:"task_id,omitempty"`
	Url        *string `json:"url,omitempty"`
}

// AttachmentKind defines model for Attachment.Kind.
type AttachmentKind string

// Blob defines model for Blob.
type Blob struct {
	ContentType string    `json:"content_type"`
	CreatedAt   time.Time `json:"created_at"`
	CreatedBy   string    `json:"created_by"`
	Id          string    `json:"id"`
}

// Caps defines model for Caps.
type Caps struct {
	// Global Most turns running at once across all vendors.
	Global int `json:"global"`

	// PerVendor Most turns running at once per vendor, keyed by vendor.
	PerVendor map[string]int `json:"per_vendor"`
}

// Error defines model for Error.
type Error struct {
	Message string `json:"message"`
}

// Event defines model for Event.
type Event struct {
	Actor          string                 `json:"actor"`
	AgentSessionId *string                `json:"agent_session_id,omitempty"`
	CreatedAt      time.Time              `json:"created_at"`
	Kind           string                 `json:"kind"`
	Payload        map[string]interface{} `json:"payload"`
	ProjectId      *string                `json:"project_id,omitempty"`
	Seq            int64                  `json:"seq"`
	TaskId         *string                `json:"task_id,omitempty"`
}

// FileChange defines model for FileChange.
type FileChange struct {
	Additions int  `json:"additions"`
	Binary    bool `json:"binary"`
	Deletions int  `json:"deletions"`

	// OldPath renamed: the path before the rename.
	OldPath *string          `json:"old_path,omitempty"`
	Path    string           `json:"path"`
	Status  FileChangeStatus `json:"status"`
}

// FileChangeStatus defines model for FileChange.Status.
type FileChangeStatus string

// FileDiff defines model for FileDiff.
type FileDiff struct {
	Patch string `json:"patch"`
	Path  string `json:"path"`
}

// InboxItem defines model for InboxItem.
type InboxItem struct {
	AgentSessionId string        `json:"agent_session_id"`
	Blocking       bool          `json:"blocking"`
	CreatedAt      time.Time     `json:"created_at"`
	Id             string        `json:"id"`
	Kind           InboxItemKind `json:"kind"`

	// Payload question: context, question, why_blocked, options, recommended_option, attachments. report: text (the final message of a turn that ended normally). session_error: error. rate_limited: vendor, rate_limit (the vendor's rate-limit status), error.
	Payload      map[string]interface{} `json:"payload"`
	Priority     InboxItemPriority      `json:"priority"`
	ProjectId    string                 `json:"project_id"`
	ResolvedAt   *time.Time             `json:"resolved_at,omitempty"`
	ResolvedBy   *string                `json:"resolved_by,omitempty"`
	Responses    []InboxResponse        `json:"responses"`
	SnoozedUntil *time.Time             `json:"snoozed_until,omitempty"`
	State        InboxState             `json:"state"`
	TaskId       string                 `json:"task_id"`
	ThreadId     string                 `json:"thread_id"`
}

// InboxItemKind defines model for InboxItem.Kind.
type InboxItemKind string

// InboxItemPriority defines model for InboxItem.Priority.
type InboxItemPriority string

// InboxRespond defines model for InboxRespond.
type InboxRespond struct {
	Responses []InboxResponseCreate `json:"responses"`
}

// InboxResponse defines model for InboxResponse.
type InboxResponse struct {
	Attachments []Attachment      `json:"attachments"`
	CreatedAt   time.Time         `json:"created_at"`
	DeliveredAt *time.Time        `json:"delivered_at,omitempty"`
	Id          string            `json:"id"`
	ItemId      string            `json:"item_id"`
	Option      *string           `json:"option,omitempty"`
	SnoozeUntil *time.Time        `json:"snooze_until,omitempty"`
	Text        *string           `json:"text,omitempty"`
	Type        InboxResponseType `json:"type"`
	User        string            `json:"user"`
}

// InboxResponseCreate defines model for InboxResponseCreate.
type InboxResponseCreate struct {
	Attachments *[]Attachment `json:"attachments,omitempty"`
	ItemId      string        `json:"item_id"`

	// Option option: one of the question's options.
	Option *string `json:"option,omitempty"`

	// SnoozeUntil snooze: when the item reappears.
	SnoozeUntil *time.Time `json:"snooze_until,omitempty"`

	// Text other: the text sent to the agent.
	Text *string           `json:"text,omitempty"`
	Type InboxResponseType `json:"type"`
}

// InboxResponseType defines model for InboxResponseType.
type InboxResponseType string

// InboxState defines model for InboxState.
type InboxState string

// MessageCreate defines model for MessageCreate.
type MessageCreate struct {
	// Images Blob ids from uploadBlob, sent to the agent as images alongside the text.
	Images *[]string `json:"images,omitempty"`

	// Model Model for this turn and later ones. When it differs from the session's model, the session switches before the message is sent.
	Model *string `json:"model,omitempty"`

	// Text May be empty when images are given.
	Text string `json:"text"`
}

// Project defines model for Project.
type Project struct {
	CreatedAt     time.Time `json:"created_at"`
	CreatedBy     string    `json:"created_by"`
	DefaultBranch string    `json:"default_branch"`
	Id            string    `json:"id"`
	Name          string    `json:"name"`
	Remote        string    `json:"remote"`
	RepoPath      string    `json:"repo_path"`
}

// ProjectCreate defines model for ProjectCreate.
type ProjectCreate struct {
	Name     string `json:"name"`
	RepoPath string `json:"repo_path"`
}

// SessionCreate defines model for SessionCreate.
type SessionCreate struct {
	// Images Blob ids from uploadBlob, sent to the agent as images alongside the prompt.
	Images *[]string `json:"images,omitempty"`
	Model  *string   `json:"model,omitempty"`
	Prompt string    `json:"prompt"`
}

// Status defines model for Status.
type Status struct {
	ActiveTasks  int   `json:"active_tasks"`
	Caps         Caps  `json:"caps"`
	DbBytes      int64 `json:"db_bytes"`
	LastEventSeq int64 `json:"last_event_seq"`

	// LiveAgents Agent processes currently running.
	LiveAgents int `json:"live_agents"`
	Projects   int `json:"projects"`

	// QueuedTurns Turns waiting for room under the caps, in the order they will start.
	QueuedTurns []TurnRef `json:"queued_turns"`

	// RateLimits The latest rate-limit status each vendor reported, keyed by vendor.
	RateLimits map[string]map[string]interface{} `json:"rate_limits"`

	// RunningTurns Turns running now, oldest session first.
	RunningTurns []TurnRef `json:"running_turns"`
	SseClients   int       `json:"sse_clients"`
	StartedAt    time.Time `json:"started_at"`
}

// Task defines model for Task.
type Task struct {
	BaseRef string `json:"base_ref"`
	Branch  string `json:"branch"`

	// ClosedAt When the task was merged or discarded.
	ClosedAt  *time.Time `json:"closed_at,omitempty"`
	CreatedAt time.Time  `json:"created_at"`
	CreatedBy string     `json:"created_by"`
	Id        string     `json:"id"`

	// MergeCommit merged: the squash commit on the default branch; empty when there was nothing to merge.
	MergeCommit  *string    `json:"merge_commit,omitempty"`
	ProjectId    string     `json:"project_id"`
	Status       TaskStatus `json:"status"`
	Title        string     `json:"title"`
	WorktreePath string     `json:"worktree_path"`
}

// TaskStatus defines model for Task.Status.
type TaskStatus string

// TaskChanges defines model for TaskChanges.
type TaskChanges struct {
	// Base Merge-base commit of the task branch and the default branch.
	Base  string       `json:"base"`
	Files []FileChange `json:"files"`

	// Tree Tree of the worktree as if everything were staged.
	Tree string `json:"tree"`
}

// TaskCreate defines model for TaskCreate.
type TaskCreate struct {
	Title string `json:"title"`
}

// TurnRef defines model for TurnRef.
type TurnRef struct {
	SessionId string `json:"session_id"`
	TaskId    string `json:"task_id"`
	Vendor    string `json:"vendor"`
}

// Unmerged defines model for Unmerged.
type Unmerged struct {
	// Commits Commits on the task branch that aren't on the default branch.
	Commits   int `json:"commits"`
	Deletions int `json:"deletions"`

	// Files Files that differ from the merge base
	Files      int `json:"files"`
	Insertions int `json:"insertions"`

	// Uncommitted Paths with uncommitted changes in the worktree.
	Uncommitted int `json:"uncommitted"`
}

// User defines model for User.
type User struct {
	DisplayName string `json:"display_name"`
	GitEmail    string `json:"git_email"`
	GitName     string `json:"git_name"`
	Login       string `json:"login"`
}

// UserUpdate defines model for UserUpdate.
type UserUpdate struct {
	GitEmail string `json:"git_email"`
	GitName  string `json:"git_name"`
}

// StreamEventsParams defines parameters for StreamEvents.
type StreamEventsParams struct {
	After       *int64 `form:"after,omitempty" json:"after,omitempty"`
	LastEventID *int64 `json:"Last-Event-ID,omitempty"`
}

// ListInboxParams defines parameters for ListInbox.
type ListInboxParams struct {
	ProjectId      *string     `form:"project_id,omitempty" json:"project_id,omitempty"`
	TaskId         *string     `form:"task_id,omitempty" json:"task_id,omitempty"`
	State          *InboxState `form:"state,omitempty" json:"state,omitempty"`
	IncludeSnoozed *bool       `form:"include_snoozed,omitempty" json:"include_snoozed,omitempty"`
}

// GetTaskChangesParams defines parameters for GetTaskChanges.
type GetTaskChangesParams struct {
	// Since A commit to compare with instead of the merge-base, such as a user.message event's head.
	Since *string `form:"since,omitempty" json:"since,omitempty"`
}

// GetTaskDiffParams defines parameters for GetTaskDiff.
type GetTaskDiffParams struct {
	Base    string  `form:"base" json:"base"`
	Tree    string  `form:"tree" json:"tree"`
	Path    string  `form:"path" json:"path"`
	OldPath *string `form:"old_path,omitempty" json:"old_path,omitempty"`
}

// ListTaskEventsParams defines parameters for ListTaskEvents.
type ListTaskEventsParams struct {
	After *int64 `form:"after,omitempty" json:"after,omitempty"`
	Limit *int   `form:"limit,omitempty" json:"limit,omitempty"`
}

// RespondInboxJSONRequestBody defines body for RespondInbox for application/json ContentType.
type RespondInboxJSONRequestBody = InboxRespond

// UpdateMeJSONRequestBody defines body for UpdateMe for application/json ContentType.
type UpdateMeJSONRequestBody = UserUpdate

// CreateProjectJSONRequestBody defines body for CreateProject for application/json ContentType.
type CreateProjectJSONRequestBody = ProjectCreate

// CreateTaskJSONRequestBody defines body for CreateTask for application/json ContentType.
type CreateTaskJSONRequestBody = TaskCreate

// SendMessageJSONRequestBody defines body for SendMessage for application/json ContentType.
type SendMessageJSONRequestBody = MessageCreate

// CreateSessionJSONRequestBody defines body for CreateSession for application/json ContentType.
type CreateSessionJSONRequestBody = SessionCreate

// ServerInterface represents all server handlers.
type ServerInterface interface {

	// (GET /api/admin/status)
	GetStatus(w http.ResponseWriter, r *http.Request)

	// (POST /api/blobs)
	UploadBlob(w http.ResponseWriter, r *http.Request)

	// (GET /api/blobs/{blobId})
	GetBlob(w http.ResponseWriter, r *http.Request, blobId string)

	// (GET /api/events)
	StreamEvents(w http.ResponseWriter, r *http.Request, params StreamEventsParams)

	// (GET /api/inbox)
	ListInbox(w http.ResponseWriter, r *http.Request, params ListInboxParams)

	// (POST /api/inbox/responses)
	RespondInbox(w http.ResponseWriter, r *http.Request)

	// (GET /api/inbox/{itemId})
	GetInboxItem(w http.ResponseWriter, r *http.Request, itemId string)

	// (GET /api/me)
	GetMe(w http.ResponseWriter, r *http.Request)

	// (PUT /api/me)
	UpdateMe(w http.ResponseWriter, r *http.Request)

	// (GET /api/projects)
	ListProjects(w http.ResponseWriter, r *http.Request)

	// (POST /api/projects)
	CreateProject(w http.ResponseWriter, r *http.Request)

	// (GET /api/projects/{projectId})
	GetProject(w http.ResponseWriter, r *http.Request, projectId string)

	// (GET /api/projects/{projectId}/tasks)
	ListTasks(w http.ResponseWriter, r *http.Request, projectId string)

	// (POST /api/projects/{projectId}/tasks)
	CreateTask(w http.ResponseWriter, r *http.Request, projectId string)

	// (GET /api/sessions/{sessionId})
	GetSession(w http.ResponseWriter, r *http.Request, sessionId string)

	// (POST /api/sessions/{sessionId}/compact)
	CompactSession(w http.ResponseWriter, r *http.Request, sessionId string)

	// (POST /api/sessions/{sessionId}/interrupt)
	InterruptSession(w http.ResponseWriter, r *http.Request, sessionId string)

	// (POST /api/sessions/{sessionId}/messages)
	SendMessage(w http.ResponseWriter, r *http.Request, sessionId string)

	// (GET /api/tasks/{taskId})
	GetTask(w http.ResponseWriter, r *http.Request, taskId string)

	// (GET /api/tasks/{taskId}/changes)
	GetTaskChanges(w http.ResponseWriter, r *http.Request, taskId string, params GetTaskChangesParams)

	// (GET /api/tasks/{taskId}/diff)
	GetTaskDiff(w http.ResponseWriter, r *http.Request, taskId string, params GetTaskDiffParams)

	// (POST /api/tasks/{taskId}/discard)
	DiscardTask(w http.ResponseWriter, r *http.Request, taskId string)

	// (GET /api/tasks/{taskId}/events)
	ListTaskEvents(w http.ResponseWriter, r *http.Request, taskId string, params ListTaskEventsParams)

	// (POST /api/tasks/{taskId}/merge)
	MergeTask(w http.ResponseWriter, r *http.Request, taskId string)

	// (POST /api/tasks/{taskId}/merge-in)
	MergeIn(w http.ResponseWriter, r *http.Request, taskId string)

	// (GET /api/tasks/{taskId}/sessions)
	ListSessions(w http.ResponseWriter, r *http.Request, taskId string)

	// (POST /api/tasks/{taskId}/sessions)
	CreateSession(w http.ResponseWriter, r *http.Request, taskId string)

	// (GET /api/tasks/{taskId}/unmerged)
	GetUnmerged(w http.ResponseWriter, r *http.Request, taskId string)
}

// 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

// GetStatus operation middleware
func (siw *ServerInterfaceWrapper) GetStatus(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetStatus(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// UploadBlob operation middleware
func (siw *ServerInterfaceWrapper) UploadBlob(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.UploadBlob(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetBlob operation middleware
func (siw *ServerInterfaceWrapper) GetBlob(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "blobId" -------------
	var blobId string

	err = runtime.BindStyledParameterWithOptions("simple", "blobId", r.PathValue("blobId"), &blobId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "blobId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetBlob(w, r, blobId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// StreamEvents operation middleware
func (siw *ServerInterfaceWrapper) StreamEvents(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// Parameter object where we will unmarshal all parameters from the context
	var params StreamEventsParams

	// ------------- Optional query parameter "after" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "after", r.URL.Query(), &params.After, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "after"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "after", Err: err})
		}
		return
	}

	headers := r.Header

	// ------------- Optional header parameter "Last-Event-ID" -------------
	if valueList, found := headers[http.CanonicalHeaderKey("Last-Event-ID")]; found {
		var LastEventID int64
		n := len(valueList)
		if n != 1 {
			siw.ErrorHandlerFunc(w, r, &TooManyValuesForParamError{ParamName: "Last-Event-ID", Count: n})
			return
		}

		err = runtime.BindStyledParameterWithOptions("simple", "Last-Event-ID", valueList[0], &LastEventID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationHeader, Explode: false, Required: false, Type: "integer", Format: "int64"})
		if err != nil {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "Last-Event-ID", Err: err})
			return
		}

		params.LastEventID = &LastEventID

	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.StreamEvents(w, r, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListInbox operation middleware
func (siw *ServerInterfaceWrapper) ListInbox(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// Parameter object where we will unmarshal all parameters from the context
	var params ListInboxParams

	// ------------- Optional query parameter "project_id" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "project_id", r.URL.Query(), &params.ProjectId, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "project_id"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "project_id", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "task_id" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "task_id", r.URL.Query(), &params.TaskId, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "task_id"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "task_id", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "state" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "state", r.URL.Query(), &params.State, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "state"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "state", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "include_snoozed" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "include_snoozed", r.URL.Query(), &params.IncludeSnoozed, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "include_snoozed"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include_snoozed", Err: err})
		}
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListInbox(w, r, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// RespondInbox operation middleware
func (siw *ServerInterfaceWrapper) RespondInbox(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.RespondInbox(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetInboxItem operation middleware
func (siw *ServerInterfaceWrapper) GetInboxItem(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "itemId" -------------
	var itemId string

	err = runtime.BindStyledParameterWithOptions("simple", "itemId", r.PathValue("itemId"), &itemId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "itemId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetInboxItem(w, r, itemId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetMe operation middleware
func (siw *ServerInterfaceWrapper) GetMe(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetMe(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// UpdateMe operation middleware
func (siw *ServerInterfaceWrapper) UpdateMe(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.UpdateMe(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListProjects operation middleware
func (siw *ServerInterfaceWrapper) ListProjects(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListProjects(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// CreateProject operation middleware
func (siw *ServerInterfaceWrapper) CreateProject(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.CreateProject(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetProject operation middleware
func (siw *ServerInterfaceWrapper) GetProject(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "projectId" -------------
	var projectId string

	err = runtime.BindStyledParameterWithOptions("simple", "projectId", r.PathValue("projectId"), &projectId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "projectId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetProject(w, r, projectId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListTasks operation middleware
func (siw *ServerInterfaceWrapper) ListTasks(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "projectId" -------------
	var projectId string

	err = runtime.BindStyledParameterWithOptions("simple", "projectId", r.PathValue("projectId"), &projectId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "projectId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListTasks(w, r, projectId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// CreateTask operation middleware
func (siw *ServerInterfaceWrapper) CreateTask(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "projectId" -------------
	var projectId string

	err = runtime.BindStyledParameterWithOptions("simple", "projectId", r.PathValue("projectId"), &projectId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "projectId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.CreateTask(w, r, projectId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetSession operation middleware
func (siw *ServerInterfaceWrapper) GetSession(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "sessionId" -------------
	var sessionId string

	err = runtime.BindStyledParameterWithOptions("simple", "sessionId", r.PathValue("sessionId"), &sessionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sessionId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetSession(w, r, sessionId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// CompactSession operation middleware
func (siw *ServerInterfaceWrapper) CompactSession(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "sessionId" -------------
	var sessionId string

	err = runtime.BindStyledParameterWithOptions("simple", "sessionId", r.PathValue("sessionId"), &sessionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sessionId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.CompactSession(w, r, sessionId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// InterruptSession operation middleware
func (siw *ServerInterfaceWrapper) InterruptSession(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "sessionId" -------------
	var sessionId string

	err = runtime.BindStyledParameterWithOptions("simple", "sessionId", r.PathValue("sessionId"), &sessionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sessionId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.InterruptSession(w, r, sessionId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// SendMessage operation middleware
func (siw *ServerInterfaceWrapper) SendMessage(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "sessionId" -------------
	var sessionId string

	err = runtime.BindStyledParameterWithOptions("simple", "sessionId", r.PathValue("sessionId"), &sessionId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sessionId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.SendMessage(w, r, sessionId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetTask operation middleware
func (siw *ServerInterfaceWrapper) GetTask(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetTask(w, r, taskId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetTaskChanges operation middleware
func (siw *ServerInterfaceWrapper) GetTaskChanges(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params GetTaskChangesParams

	// ------------- Optional query parameter "since" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "since", r.URL.Query(), &params.Since, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "since"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "since", Err: err})
		}
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetTaskChanges(w, r, taskId, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetTaskDiff operation middleware
func (siw *ServerInterfaceWrapper) GetTaskDiff(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params GetTaskDiffParams

	// ------------- Required query parameter "base" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "base", r.URL.Query(), &params.Base, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "base"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "base", Err: err})
		}
		return
	}

	// ------------- Required query parameter "tree" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "tree", r.URL.Query(), &params.Tree, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "tree"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "tree", Err: err})
		}
		return
	}

	// ------------- Required query parameter "path" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "path", r.URL.Query(), &params.Path, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "path"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "path", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "old_path" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "old_path", r.URL.Query(), &params.OldPath, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "old_path"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "old_path", Err: err})
		}
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetTaskDiff(w, r, taskId, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// DiscardTask operation middleware
func (siw *ServerInterfaceWrapper) DiscardTask(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.DiscardTask(w, r, taskId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListTaskEvents operation middleware
func (siw *ServerInterfaceWrapper) ListTaskEvents(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params ListTaskEventsParams

	// ------------- Optional query parameter "after" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "after", r.URL.Query(), &params.After, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "after"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "after", Err: err})
		}
		return
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "limit", r.URL.Query(), &params.Limit, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
	if err != nil {
		var requiredError *runtime.RequiredParameterError
		if errors.As(err, &requiredError) {
			siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "limit"})
		} else {
			siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
		}
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListTaskEvents(w, r, taskId, params)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// MergeTask operation middleware
func (siw *ServerInterfaceWrapper) MergeTask(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.MergeTask(w, r, taskId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// MergeIn operation middleware
func (siw *ServerInterfaceWrapper) MergeIn(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.MergeIn(w, r, taskId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// ListSessions operation middleware
func (siw *ServerInterfaceWrapper) ListSessions(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.ListSessions(w, r, taskId)
	}))

	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) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.CreateSession(w, r, taskId)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

// GetUnmerged operation middleware
func (siw *ServerInterfaceWrapper) GetUnmerged(w http.ResponseWriter, r *http.Request) {

	var err error
	_ = err

	// ------------- Path parameter "taskId" -------------
	var taskId string

	err = runtime.BindStyledParameterWithOptions("simple", "taskId", r.PathValue("taskId"), &taskId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "taskId", Err: err})
		return
	}

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetUnmerged(w, r, taskId)
	}))

	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, StdHTTPServerOptions{})
}

// ServeMux is an abstraction of [http.ServeMux].
type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	http.Handler
}

type StdHTTPServerOptions struct {
	BaseURL          string
	BaseRouter       ServeMux
	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, m ServeMux) http.Handler {
	return HandlerWithOptions(si, StdHTTPServerOptions{
		BaseRouter: m,
	})
}

func HandlerFromMuxWithBaseURL(si ServerInterface, m ServeMux, baseURL string) http.Handler {
	return HandlerWithOptions(si, StdHTTPServerOptions{
		BaseURL:    baseURL,
		BaseRouter: m,
	})
}

// HandlerWithOptions creates http.Handler with additional options
func HandlerWithOptions(si ServerInterface, options StdHTTPServerOptions) http.Handler {
	m := options.BaseRouter

	if m == nil {
		m = http.NewServeMux()
	}
	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,
	}

	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/me", wrapper.GetMe)
	m.HandleFunc(http.MethodPut+" "+options.BaseURL+"/api/me", wrapper.UpdateMe)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/projects", wrapper.ListProjects)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/projects", wrapper.CreateProject)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/projects/{projectId}", wrapper.GetProject)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/projects/{projectId}/tasks", wrapper.ListTasks)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/projects/{projectId}/tasks", wrapper.CreateTask)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/tasks/{taskId}", wrapper.GetTask)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/tasks/{taskId}/unmerged", wrapper.GetUnmerged)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/tasks/{taskId}/merge", wrapper.MergeTask)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/tasks/{taskId}/merge-in", wrapper.MergeIn)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/tasks/{taskId}/discard", wrapper.DiscardTask)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/tasks/{taskId}/events", wrapper.ListTaskEvents)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/tasks/{taskId}/changes", wrapper.GetTaskChanges)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/tasks/{taskId}/diff", wrapper.GetTaskDiff)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/tasks/{taskId}/sessions", wrapper.ListSessions)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/tasks/{taskId}/sessions", wrapper.CreateSession)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/sessions/{sessionId}", wrapper.GetSession)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/sessions/{sessionId}/messages", wrapper.SendMessage)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/sessions/{sessionId}/compact", wrapper.CompactSession)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/sessions/{sessionId}/interrupt", wrapper.InterruptSession)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/blobs", wrapper.UploadBlob)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/blobs/{blobId}", wrapper.GetBlob)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/inbox", wrapper.ListInbox)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/inbox/{itemId}", wrapper.GetInboxItem)
	m.HandleFunc(http.MethodPost+" "+options.BaseURL+"/api/inbox/responses", wrapper.RespondInbox)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/events", wrapper.StreamEvents)
	m.HandleFunc(http.MethodGet+" "+options.BaseURL+"/api/admin/status", wrapper.GetStatus)

	return m
}

// Base64 encoded, compressed with deflate, json marshaled OpenAPI spec.
// Stored as a slice of fixed-width chunks rather than one concatenated
// const string: with thousands of chunks the chained `+` fold is several
// times slower for the Go compiler than parsing a slice literal.
var swaggerSpec = []string{
	"7Fzdb9u4lv9XCO0CaQHFydw7d4H1PHXaziAX09lu02Ie7g4MWjq2OJFIlaTieoP874tzSOrDomwnE6e9",
	"uPsURx/k4eHvfB/qLslUVSsJ0ppkfpdoMLWSBuift1orjT8yJS1Iiz95XZci41YoefGHURKvmayAiuOv",
	"f9ewSubJv110o164u+bCjXZ/f58mOZhMixoHSeZumlmCN/yzONSrNUh7DcYIN0mtVQ3aCkdapoFbyBec",
	"iFopXeGvJOcWzq2oIEkTu60hmSfGaiHXyX3avrPc4juj2yKPXq5UDiXeGRL9AT43YCzkjB74gUFV2y2r",
	"gEvDbAHsFmSu9JlhOax4U9pZjCStSsCxQTZVMv9HIqq6hAqkBZ38HnneWG5hTMznBhqkhCbnzDZaMmHY",
	"hgsr5JqtlGacrTQAM6WyrJE5aCIyUzJrtAaZbVnGa4NEtrTkJbLRjZ2kiW6kRDJSgkwJFvIxjWny5RwH",
	"OL/lWvIKN+sfg628xhVcuaFH1/87zDW686GdfHTrdUfNfZpYbm4WE1vptqTP76zkTQ5RVruHF8bNFB8S",
	"dxA+N0JD7jiWdAS00wUIxYYMO+qRMMBo2gd5R6Fa/gGZRQpfWcuzovKCuSMf3GMjwgaQ+aIUEno3hbSw",
	"Bk1iUPF1BGJ0ec5ybjn79OGXKJpvhMz73F0JWlMuVqskDIz/8rXmlWcVskDy2hTKJmnS6DK6GRXoirst",
	"GJLlB5uzd+4JZlSjM4iSV3NbjEdAIudMQ63ONZTciltg+GRcXlG9jWlYreZsLSzTcCtwa5nmch0nIix2",
	"CqPGcm33bM8+fCP3DoKUNikGpx9LtYwAyan+hXv8blqrnloTx2RtQNzDhOc1r814tetSLXlE279TxpJa",
	"NcyrQcYtUzIDxjOtjGG8LL3KN719721cDXrRKSCe5wLH5uX7AQHj944mpAbtKUjZDWwhZ8utv9CjKHBg",
	"h51+4QMyY2xrXYIh3yowxquN/dsWHoyOfRtVZTyzbsoRTjiagv0a+nH4DIosokK2peL9ex35tVb4c1Kw",
	"4fOAACHtf3wfRcq0iO8wE4f0xKaeTR2JByXgJ1HC6wIVVYTnHp4TmFwKyXVfdpdKlcClw2sJe15VZb6I",
	"K2IN6DDkc3JM8BG2hJXSQP+7m3vVetRZakzfIPE8J/eiUrlYCfpJ5Dr/xs3vp1hkxJqIi7O7CzR/O1va",
	"412fGS3TprbiDVrJ0UbU3GbFBBSjy44T54aJTX0ll+rLlYUqAoJjxGtZquwGf0fB8Bjhm5ho17kg9xuR",
	"gwuulUb3IdAKpKXSRHMLi1JUIuqrDuV55FHT6HNGNuaLTVm4lLJNsV3QuiFPmaJXTMo0ZKqqQOaQL9zF",
	"lPHWRTMz5sicMxyOvUBUr4TkJfM6kalV8N1twS2jkZhEnpXl9uWMDVY3Z/RnxvprnLcGoLvqZmqjEbxx",
	"7m44xL5M/Uj/I5M0ptWE0sJu+6z3a0/SZO2dV7gVsEnSZLUVcT7v140ajCpvH4iT9qUJL2IQygoLlTkU",
	"oZIsfPCvkSZ2Y3Kt+dY5b0r9L+SLRlpRHk9pG7UdnJwCmkNuni008Pz4iKTH/H54MhLv/sitWWn3vyfq",
	"fSMT4peepPdZP6lyHJvzsdb5k9v2muigmEHIK/f6d7s7ucOlo8k1MVPZifjRFPcitwjKHqM0cyjFLein",
	"UbW4hinwqem40knHQ4UDtWEc5j7iOHrrP+ILGAYZ0EeKRlipf8lPmg429aAjFcPfM8DkuF0amjV3fc6U",
	"JHODliGYtTMTTNlE3Drc3OG47u6cbQqQNCoSxzTwugbuIqKHoWGHbFuAdo4hGU8D0jKr6AKpsSjJjwTQ",
	"Lk5aiNB4BwHw0c8ajKXfitQtIgmcpESIqYQxUYPZswaDsQBH4tJsUNa7Mei3aWrQBvIJX+edczOmAErp",
	"GTPm/Y+lWjKRG7bSqmJNjXofr6XjXWDcMDcM46WSayNyaDdt5sXN7BH2DtwTWdd3eJnymbYQxjlLXOas",
	"5BY0otrM2G+IQWFZLlYr0J5upMKbujPjUrZp/yIzG2GzAkw/6AiOmTC01tnxgH3Ht2wJPidMQhH4ooGt",
	"xS3IyGA7wKORY3B77+z5syTFffJ6sdRcTgQiEyoIg6kJv6xSdupWrRbHBTYkkTRH/7URwe10D8sOeRZP",
	"ycqetR29gBHtMTp8nvtryGytVVU/VmpjAUBV2yPiVfdclBdtOD/KD4lbWKBjO5FzyHyub58hoHwgAn65",
	"WG6tG/mIXE3JjV3ArfOkj03woKu2IO5H9o7qG8j9DIwBw1x9xpbbkPCbSC86xE5wwBVxFpQ4HE/5kfKJ",
	"/WqRVoibrkzEa5My4Uy70v7ylm1EWTLKWA9wso/PONcHWMXQ08Ws5ogUaQeMncUUQObA2HGsy4BnhY+F",
	"fTiOIfzhbGlb/drPwpCSlWqTMlXmSEQwMCuhzZOwyRhYZKUI6BlvNm3Ig8zAbl6xG6AnECOw90CXDqVw",
	"SOQQ8Lus3AGnl9YhGmLq4CM3N2NlsOQGFr5KM85VTRuxrFSmZdlwa38LPi2ujW24YRXoNeRMaZYLk3Gd",
	"Q368h/uMlWskc5GpqhKRZblFOKfafG64KZh7lCm3XG9JmePaD31nBj1ZIFZIZQtEvFWOK/EM7YHM+DhP",
	"S2BK/BK8n+sYfWTJGdHhDMarMFZ36V0Ytbv0phsfRU7YMm7gN0rfWA3wEC9lmH+hoVss7o6YdgjupZQf",
	"4rrgmlxa38TFI+KtIj/O8V4LgVWHeEcpudljWET3eyXKB6RvenWIiLZD1kTUrYY2gA0MJE9mxeAW9NaB",
	"EoMk1PxrJ5/7t4pY4+cLS5jk74Q/NoWbXc+eHosO7tX+aOQDWfjjuh4OVZP6mcDdLoYYtZ+kl89I1bgK",
	"Zny4ca/djaBj+gCjpDfXIM8mVFDc8TlQb2qxOKQDQWfclC5O7MJEWhMLcBgOmCaNdGuzkDNXIjJMyKxs",
	"yAjMZVOWqJGlQWZMUtUbZUzbe24LwzbCFiw+2wD2Ma7s7GzYjcCNAX3DIlWfsOiW+9zacLtzYeqSbxeT",
	"cdFa2AVUXJSTdydfLdVayMPodY+lQ1J6Q/dpmFrYpzqPivWjqd8tsh9HzD0BaKV6GiVZbjWQMGrXD5dc",
	"zi5nly7VB5LXIpknf51dzv7qin0F0X3Ba3HB80rIi87GroGcAVwfdfFd5ck8+RnsdTA2gwT8Xy4vn6wB",
	"0M8Q6QC8Bn0LmhXAS+ssTWM4OhP39DCtY1mqpbNoykTcmWurNMawPtNCUUxjAKWFh0TOjGFwsFT5lgnX",
	"pKf5xj3/A0OthBuBt3KwkKHMtUqBXGCirGqMZUtg73/9OWV/f//255T9fPUTOoO/wfL9jL2yrFLGsr+x",
	"d+JHV1Qb8vpTG44nDh5g7I8q3+7wmci6WIvVkMGtw+jLyTGz5l79o4b1Y9+t5aNf3cCyfui7AzmxuoH7",
	"EQy/ezIYEucjIERsGERRzhBrMxSu7x38Y8O19IXG1jT5/ru/Hv30DrAv7vDPVX6/T0RbzOwV0H8x4Iw3",
	"ETl5ZpzIps6OonB7FpGQ+839/gHbhXpV8wosaIww7hK0SqG/wun/xO1hsovmtLem3RX8HmBAcXVfQ8dU",
	"5Dnl79yjM/aWZ4X758wwkaPmwoUa+PyDa9T0Wo4aq9A9/vv1f/06c/8axlcWNPuFG3tOV86v3rAXyiV8",
	"3L3PDegta5f9krLXGtC+opC4RDnG9oGiiLa7thp45aZM4jwsgOfkW3kuDkhK0hggpnJr96kfk0jvhqT1",
	"PHCo3w9KmoUv1u3buaFlDuF7EKxuX9yrA1sn5FJ9mYQC1YaowmZSVoh1AcayUKd3eSb2ou1PWXMLKXMd",
	"GilbbcVLKnzIkJ9yeSn2kyhxV5jkWquNS/RJ8BCwinHmw9gzw6idHF33M8Nw2Ni+/yKMJUInNn1ngwYx",
	"8jQLJ7a3i1Ye/GroXzjOdvSbNKZG9NHAwjeLxIhqO6SOANl+Q3d8gwT1eI0C7DEo33GbUfRMQzv1aQsQ",
	"mrWEztgbF5gZRAY6oClrpF+ve28M54vBOuNO3CsqbBpXntasQv3iyBCSLppmWQkKU2csPKwpqTsoaOCj",
	"bVeVzHAQUo55CeTDSV//Rm0ZulraQrgr0jUyVFlj6PbdKwHg017c492UQZfMUS7S10YO2t6GQqgOBA92",
	"oR5gk/Hp/3yEw+XgeIckHnC4uuWfMCzq8TjOU+qlaN2YTgpP48M4tjzOh3FB8BQ338Ep2UiZiQkOZrws",
	"UcQbA3TQDBnRRIh0CQBP59OLdC/HcAKBfixzgsh65jxMYjup6hcgowhAj+B9VzA6vfIKfRJHqK5XZRn8",
	"GxMA4i3UcBEu8xtGPg1Mhs0Hzxwdt0yLg0XCJjDqCbByced/HdDDfX6fSEIOrHu45qfWuS0XHqd2Y+y8",
	"aPshJoXxo6/Vnl4SqVZ7pAfRhRm0ghQh18Up3xT/0wk31kmuaSscZ6ZfRGvrVW1ysVvyuOARUz8f3bnJ",
	"U+ieXnXrmRWPw8i01kFGntih7BSUr4WZizv/64CCCufUT6igBufhp9KX7vaJpKRlxeO0VIynRBX3vYyn",
	"ImBKTF+ZGyejFBd23aEujHSH5gsuc7VasRdrxcuU5ZDRAV+TUkcR4BWeM5C5SSkQ7qLIlFGx7aVvSKVS",
	"I/Wruof7vafCsPZIPakITogPt30x1PDKF0ypDEGdsNSp0wXpLbncZQJdLihUPyJx7GvH/kn4/uVZ4Ruo",
	"JzZtuGG+EYkpykU2kM+eK0aMglVIC1o39deB61uZO7j6jkBi09hEXAUiv5FNbZlGO9qeU/m6O+lFwnyV",
	"jbx2QuuE3GHdya8ww0plUACh5Ih6arzh1yBz39t/IqdgeHLgKL/geTFGTCw6hfGNJp7Iob24wz8H/InW",
	"wzuRM7HP2eo5Wk/tQbiVP859GDLvIuta3KJFkrddG5iQfU+8db9ftJ0uqW8Soyw2/XI9CNJq7ooouF7I",
	"qD16thZWrKXS8BLNLGc4WEoGnGvIO1tcdV11e9rppnz/FI0ejWWEzMD1XbqTI6QbwjLODFMbyYTM4Qs6",
	"ElJZZlWTFfHEtcdWaBAcbdqOhxT6Aa0KC/SJSGksOj5+Yd1SU2YaXB0yhhJKIQ0fypQFcGrGi9ZicKXJ",
	"AZ16UpkIfImIxnvQ5+jRkeP3raW2n1n4cv+tgqjkUU5R0vcVqLcOQaIkkDvMlmA3AJJxarBzUtDGwusB",
	"OGdT4H3jvid0RFXRN/Edv+Cp+qJrCv3T4/gN+dPjtB/R+Fqy0n6wYiqJw21W/KvLCHWUH+dhPmbeKffy",
	"A1Tqdph96lqkZR4MEOpx1VjS3UKunVXxz2vIlHZG0HV2MA0VF5Fow/fNf01/pT0a8DjP5WmcuUPtOz3m",
	"Qr/9hjMDn9OdXoz3aDCXW1ZzY+hwBR1porNEn9mSZzdkX/H9WbTvArm1t+PmCbpjJjQTHdgZDFXxL6Jq",
	"qmT+3eXlJX2Vwf/7qJabJ0hGu89MHZGN/lSj3+POj/lNexGctL9dXr789p1k8sueXwP5ALdNWrmEmjus",
	"7U9PnQsZTYy137tJ2XKrw8mkCW0mpFXkWgwPLk271Ctu7PlK6Q3XPpfSPZsVkN2gQrSKCet7pHRPl8aU",
	"KGXiuL7p6POHw2bsV38yShhWNwbdcfYBVo3BEKFAV6j7Tmc4NtiluSKeOx3SievZ5w223fmIgzm6bzv4",
	"vggofH7paNPOHs5eOlRg7B4EO8TvhJIUnarylr4FKLcsU3JVisy6dnUNa5CEI7lm/ifkLjc9Y9e94+Ce",
	"nH4ynIJQE9JVIR218R9YKOj8n4SnAPaV/H9YPwWsQ7Zzb+H3Ojz0HOZ2yPvjasADyQhL2vGSvh3jeyjP",
	"K4cLmcpHobQasoHC9r7AMKzlxHP+LjPbT/g/fRJ4+CmKZy4OHyPAvZLZP4esNr3jk9Gg4TdyjSJQKVSZ",
	"+9OLCI1Jc5ErMPLMRjMp7eHNU7adhTmmWs/8/XC2cfZPmwO4v/+/AAAA//8=",
}

// decodeSpec returns the embedded OpenAPI spec as raw JSON bytes,
// after base64-decoding and flate-decompressing the embedded blob.
func decodeSpec() ([]byte, error) {
	encoded := strings.Join(swaggerSpec, "")
	compressed, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		return nil, fmt.Errorf("error base64 decoding spec: %w", err)
	}
	zr := flate.NewReader(bytes.NewReader(compressed))
	var buf bytes.Buffer
	if _, err := buf.ReadFrom(zr); err != nil {
		return nil, fmt.Errorf("read flate: %w", err)
	}
	if err := zr.Close(); err != nil {
		return nil, fmt.Errorf("close flate reader: %w", err)
	}

	return buf.Bytes(), nil
}

var rawSpec = decodeSpecCached()

// a naive cache of the decoded OpenAPI spec
func decodeSpecCached() func() ([]byte, error) {
	data, err := decodeSpec()
	return func() ([]byte, error) {
		return data, err
	}
}

// Constructs a synthetic filesystem for resolving external references when loading openapi specifications.
func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) {
	res := make(map[string]func() ([]byte, error))
	if len(pathToFile) > 0 {
		res[pathToFile] = rawSpec
	}

	return res
}

// GetSpec returns the OpenAPI specification corresponding to the generated
// code in this file. External references in the spec are resolved through
// PathToRawSpec; externally-referenced files must be embedded in their
// corresponding Go packages (via the import-mapping feature). URL-based
// external refs are not supported.
func GetSpec() (swagger *openapi3.T, err error) {
	resolvePath := PathToRawSpec("")

	loader := openapi3.NewLoader()
	loader.IsExternalRefsAllowed = true
	loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
		pathToFile := url.String()
		pathToFile = path.Clean(pathToFile)
		getSpec, ok := resolvePath[pathToFile]
		if !ok {
			err1 := fmt.Errorf("path not found: %s", pathToFile)
			return nil, err1
		}
		return getSpec()
	}
	var specData []byte
	specData, err = rawSpec()
	if err != nil {
		return
	}
	swagger, err = loader.LoadFromData(specData)
	if err != nil {
		return
	}
	return
}

// GetSpecJSON returns the raw JSON bytes of the embedded OpenAPI
// specification: decompressed but not unmarshaled. External references
// are not resolved here; the bytes are the spec exactly as embedded by
// codegen. The result is cached at package init time, so repeated calls
// are cheap.
func GetSpecJSON() ([]byte, error) {
	return rawSpec()
}

// GetSwagger returns the OpenAPI specification corresponding to the
// generated code in this file.
//
// Deprecated: GetSwagger predates kin-openapi renaming openapi3.Swagger
// to openapi3.T. Use [GetSpec] instead. This wrapper is retained for
// backwards compatibility.
func GetSwagger() (*openapi3.T, error) {
	return GetSpec()
}