AnthoLume/api/v1/api.gen.go

//go:build go1.22

// Package v1 provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.6.0 DO NOT EDIT.
package v1

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"time"

	"github.com/oapi-codegen/runtime"
	strictnethttp "github.com/oapi-codegen/runtime/strictmiddleware/nethttp"
	openapi_types "github.com/oapi-codegen/runtime/types"
)

const (
	BearerAuthScopes = "BearerAuth.Scopes"
)

// Defines values for BackupType.
const (
	COVERS    BackupType = "COVERS"
	DOCUMENTS BackupType = "DOCUMENTS"
)

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

// Defines values for ImportResultStatus.
const (
	EXISTS  ImportResultStatus = "EXISTS"
	FAILED  ImportResultStatus = "FAILED"
	SUCCESS ImportResultStatus = "SUCCESS"
)

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

// Defines values for ImportType.
const (
	COPY   ImportType = "COPY"
	DIRECT ImportType = "DIRECT"
)

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

// Defines values for OperationType.
const (
	CREATE OperationType = "CREATE"
	DELETE OperationType = "DELETE"
	UPDATE OperationType = "UPDATE"
)

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

// Defines values for PostAdminActionMultipartBodyAction.
const (
	BACKUP        PostAdminActionMultipartBodyAction = "BACKUP"
	CACHETABLES   PostAdminActionMultipartBodyAction = "CACHE_TABLES"
	METADATAMATCH PostAdminActionMultipartBodyAction = "METADATA_MATCH"
	RESTORE       PostAdminActionMultipartBodyAction = "RESTORE"
)

// Valid indicates whether the value is a known member of the PostAdminActionMultipartBodyAction enum.
func (e PostAdminActionMultipartBodyAction) Valid() bool {
	switch e {
	case BACKUP:
		return true
	case CACHETABLES:
		return true
	case METADATAMATCH:
		return true
	case RESTORE:
		return true
	default:
		return false
	}
}

// Defines values for GetSearchParamsSource.
const (
	AnnasArchive GetSearchParamsSource = "Annas Archive"
	LibGen       GetSearchParamsSource = "LibGen"
)

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

// Activity defines model for Activity.
type Activity struct {
	Author          *string `json:"author,omitempty"`
	DeviceId        string  `json:"device_id"`
	DocumentId      string  `json:"document_id"`
	Duration        int64   `json:"duration"`
	EndPercentage   float32 `json:"end_percentage"`
	ReadPercentage  float32 `json:"read_percentage"`
	StartPercentage float32 `json:"start_percentage"`
	StartTime       string  `json:"start_time"`
	Title           *string `json:"title,omitempty"`
}

// ActivityResponse defines model for ActivityResponse.
type ActivityResponse struct {
	Activities []Activity `json:"activities"`
}

// BackupType defines model for BackupType.
type BackupType string

// DatabaseInfo defines model for DatabaseInfo.
type DatabaseInfo struct {
	ActivitySize  int64 `json:"activity_size"`
	DevicesSize   int64 `json:"devices_size"`
	DocumentsSize int64 `json:"documents_size"`
	ProgressSize  int64 `json:"progress_size"`
}

// Device defines model for Device.
type Device struct {
	CreatedAt  *time.Time `json:"created_at,omitempty"`
	DeviceName *string    `json:"device_name,omitempty"`
	Id         *string    `json:"id,omitempty"`
	LastSynced *time.Time `json:"last_synced,omitempty"`
}

// DirectoryItem defines model for DirectoryItem.
type DirectoryItem struct {
	Name *string `json:"name,omitempty"`
	Path *string `json:"path,omitempty"`
}

// DirectoryListResponse defines model for DirectoryListResponse.
type DirectoryListResponse struct {
	CurrentPath *string          `json:"current_path,omitempty"`
	Items       *[]DirectoryItem `json:"items,omitempty"`
}

// Document defines model for Document.
type Document struct {
	Author            string     `json:"author"`
	CreatedAt         time.Time  `json:"created_at"`
	Deleted           bool       `json:"deleted"`
	Description       *string    `json:"description,omitempty"`
	Filepath          *string    `json:"filepath,omitempty"`
	Id                string     `json:"id"`
	Isbn10            *string    `json:"isbn10,omitempty"`
	Isbn13            *string    `json:"isbn13,omitempty"`
	LastRead          *time.Time `json:"last_read,omitempty"`
	Percentage        *float32   `json:"percentage,omitempty"`
	SecondsPerPercent *int64     `json:"seconds_per_percent,omitempty"`
	Title             string     `json:"title"`
	TotalTimeSeconds  *int64     `json:"total_time_seconds,omitempty"`
	UpdatedAt         time.Time  `json:"updated_at"`
	Words             *int64     `json:"words,omitempty"`
	Wpm               *float32   `json:"wpm,omitempty"`
}

// DocumentResponse defines model for DocumentResponse.
type DocumentResponse struct {
	Document Document  `json:"document"`
	Progress *Progress `json:"progress,omitempty"`
}

// DocumentsResponse defines model for DocumentsResponse.
type DocumentsResponse struct {
	Documents    []Document  `json:"documents"`
	Limit        int64       `json:"limit"`
	NextPage     *int64      `json:"next_page,omitempty"`
	Page         int64       `json:"page"`
	PreviousPage *int64      `json:"previous_page,omitempty"`
	Search       *string     `json:"search,omitempty"`
	Total        int64       `json:"total"`
	User         UserData    `json:"user"`
	WordCounts   []WordCount `json:"word_counts"`
}

// ErrorResponse defines model for ErrorResponse.
type ErrorResponse struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
}

// GraphDataPoint defines model for GraphDataPoint.
type GraphDataPoint struct {
	Date        string `json:"date"`
	MinutesRead int64  `json:"minutes_read"`
}

// GraphDataResponse defines model for GraphDataResponse.
type GraphDataResponse struct {
	GraphData []GraphDataPoint `json:"graph_data"`
}

// HomeResponse defines model for HomeResponse.
type HomeResponse struct {
	DatabaseInfo   DatabaseInfo           `json:"database_info"`
	GraphData      GraphDataResponse      `json:"graph_data"`
	Streaks        StreaksResponse        `json:"streaks"`
	UserStatistics UserStatisticsResponse `json:"user_statistics"`
}

// ImportResult defines model for ImportResult.
type ImportResult struct {
	Error  *string             `json:"error,omitempty"`
	Id     *string             `json:"id,omitempty"`
	Name   *string             `json:"name,omitempty"`
	Path   *string             `json:"path,omitempty"`
	Status *ImportResultStatus `json:"status,omitempty"`
}

// ImportResultStatus defines model for ImportResult.Status.
type ImportResultStatus string

// ImportResultsResponse defines model for ImportResultsResponse.
type ImportResultsResponse struct {
	Results *[]ImportResult `json:"results,omitempty"`
}

// ImportType defines model for ImportType.
type ImportType string

// InfoResponse defines model for InfoResponse.
type InfoResponse struct {
	RegistrationEnabled bool   `json:"registration_enabled"`
	SearchEnabled       bool   `json:"search_enabled"`
	Version             string `json:"version"`
}

// LeaderboardData defines model for LeaderboardData.
type LeaderboardData struct {
	All   []LeaderboardEntry `json:"all"`
	Month []LeaderboardEntry `json:"month"`
	Week  []LeaderboardEntry `json:"week"`
	Year  []LeaderboardEntry `json:"year"`
}

// LeaderboardEntry defines model for LeaderboardEntry.
type LeaderboardEntry struct {
	UserId string  `json:"user_id"`
	Value  float64 `json:"value"`
}

// LogEntry defines model for LogEntry.
type LogEntry = string

// LoginRequest defines model for LoginRequest.
type LoginRequest struct {
	Password string `json:"password"`
	Username string `json:"username"`
}

// LoginResponse defines model for LoginResponse.
type LoginResponse struct {
	IsAdmin  bool   `json:"is_admin"`
	Username string `json:"username"`
}

// LogsResponse defines model for LogsResponse.
type LogsResponse struct {
	Filter       *string     `json:"filter,omitempty"`
	Limit        *int64      `json:"limit,omitempty"`
	Logs         *[]LogEntry `json:"logs,omitempty"`
	NextPage     *int64      `json:"next_page,omitempty"`
	Page         *int64      `json:"page,omitempty"`
	PreviousPage *int64      `json:"previous_page,omitempty"`
	Total        *int64      `json:"total,omitempty"`
}

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

// OperationType defines model for OperationType.
type OperationType string

// Progress defines model for Progress.
type Progress struct {
	Author     *string    `json:"author,omitempty"`
	CreatedAt  *time.Time `json:"created_at,omitempty"`
	DeviceName *string    `json:"device_name,omitempty"`
	DocumentId *string    `json:"document_id,omitempty"`
	Percentage *float64   `json:"percentage,omitempty"`
	Title      *string    `json:"title,omitempty"`
	UserId     *string    `json:"user_id,omitempty"`
}

// ProgressListResponse defines model for ProgressListResponse.
type ProgressListResponse struct {
	Limit        *int64      `json:"limit,omitempty"`
	NextPage     *int64      `json:"next_page,omitempty"`
	Page         *int64      `json:"page,omitempty"`
	PreviousPage *int64      `json:"previous_page,omitempty"`
	Progress     *[]Progress `json:"progress,omitempty"`
	Total        *int64      `json:"total,omitempty"`
}

// ProgressResponse defines model for ProgressResponse.
type ProgressResponse struct {
	Progress *Progress `json:"progress,omitempty"`
}

// SearchItem defines model for SearchItem.
type SearchItem struct {
	Author     *string `json:"author,omitempty"`
	FileSize   *string `json:"file_size,omitempty"`
	FileType   *string `json:"file_type,omitempty"`
	Id         *string `json:"id,omitempty"`
	Language   *string `json:"language,omitempty"`
	Series     *string `json:"series,omitempty"`
	Title      *string `json:"title,omitempty"`
	UploadDate *string `json:"upload_date,omitempty"`
}

// SearchResponse defines model for SearchResponse.
type SearchResponse struct {
	Query   string       `json:"query"`
	Results []SearchItem `json:"results"`
	Source  string       `json:"source"`
}

// SettingsResponse defines model for SettingsResponse.
type SettingsResponse struct {
	Devices  *[]Device `json:"devices,omitempty"`
	Timezone *string   `json:"timezone,omitempty"`
	User     UserData  `json:"user"`
}

// StreaksResponse defines model for StreaksResponse.
type StreaksResponse struct {
	Streaks []UserStreak `json:"streaks"`
}

// UpdateSettingsRequest defines model for UpdateSettingsRequest.
type UpdateSettingsRequest struct {
	NewPassword *string `json:"new_password,omitempty"`
	Password    *string `json:"password,omitempty"`
	Timezone    *string `json:"timezone,omitempty"`
}

// User defines model for User.
type User struct {
	Admin     bool      `json:"admin"`
	CreatedAt time.Time `json:"created_at"`
	Id        string    `json:"id"`
}

// UserData defines model for UserData.
type UserData struct {
	IsAdmin  bool   `json:"is_admin"`
	Username string `json:"username"`
}

// UserStatisticsResponse defines model for UserStatisticsResponse.
type UserStatisticsResponse struct {
	Duration LeaderboardData `json:"duration"`
	Words    LeaderboardData `json:"words"`
	Wpm      LeaderboardData `json:"wpm"`
}

// UserStreak defines model for UserStreak.
type UserStreak struct {
	CurrentStreak          int64  `json:"current_streak"`
	CurrentStreakEndDate   string `json:"current_streak_end_date"`
	CurrentStreakStartDate string `json:"current_streak_start_date"`
	MaxStreak              int64  `json:"max_streak"`
	MaxStreakEndDate       string `json:"max_streak_end_date"`
	MaxStreakStartDate     string `json:"max_streak_start_date"`
	Window                 string `json:"window"`
}

// UsersResponse defines model for UsersResponse.
type UsersResponse struct {
	Users *[]User `json:"users,omitempty"`
}

// WordCount defines model for WordCount.
type WordCount struct {
	Count      int64  `json:"count"`
	DocumentId string `json:"document_id"`
}

// GetActivityParams defines parameters for GetActivity.
type GetActivityParams struct {
	DocFilter  *bool   `form:"doc_filter,omitempty" json:"doc_filter,omitempty"`
	DocumentId *string `form:"document_id,omitempty" json:"document_id,omitempty"`
	Offset     *int64  `form:"offset,omitempty" json:"offset,omitempty"`
	Limit      *int64  `form:"limit,omitempty" json:"limit,omitempty"`
}

// PostAdminActionMultipartBody defines parameters for PostAdminAction.
type PostAdminActionMultipartBody struct {
	Action      PostAdminActionMultipartBodyAction `json:"action"`
	BackupTypes *[]BackupType                      `json:"backup_types,omitempty"`
	RestoreFile *openapi_types.File                `json:"restore_file,omitempty"`
}

// PostAdminActionMultipartBodyAction defines parameters for PostAdminAction.
type PostAdminActionMultipartBodyAction string

// GetImportDirectoryParams defines parameters for GetImportDirectory.
type GetImportDirectoryParams struct {
	Directory *string `form:"directory,omitempty" json:"directory,omitempty"`
	Select    *string `form:"select,omitempty" json:"select,omitempty"`
}

// PostImportFormdataBody defines parameters for PostImport.
type PostImportFormdataBody struct {
	Directory string     `form:"directory" json:"directory"`
	Type      ImportType `form:"type" json:"type"`
}

// GetLogsParams defines parameters for GetLogs.
type GetLogsParams struct {
	Filter *string `form:"filter,omitempty" json:"filter,omitempty"`
	Page   *int64  `form:"page,omitempty" json:"page,omitempty"`
	Limit  *int64  `form:"limit,omitempty" json:"limit,omitempty"`
}

// UpdateUserFormdataBody defines parameters for UpdateUser.
type UpdateUserFormdataBody struct {
	IsAdmin   *bool         `form:"is_admin,omitempty" json:"is_admin,omitempty"`
	Operation OperationType `form:"operation" json:"operation"`
	Password  *string       `form:"password,omitempty" json:"password,omitempty"`
	User      string        `form:"user" json:"user"`
}

// GetDocumentsParams defines parameters for GetDocuments.
type GetDocumentsParams struct {
	Page   *int64  `form:"page,omitempty" json:"page,omitempty"`
	Limit  *int64  `form:"limit,omitempty" json:"limit,omitempty"`
	Search *string `form:"search,omitempty" json:"search,omitempty"`
}

// CreateDocumentMultipartBody defines parameters for CreateDocument.
type CreateDocumentMultipartBody struct {
	DocumentFile openapi_types.File `json:"document_file"`
}

// EditDocumentJSONBody defines parameters for EditDocument.
type EditDocumentJSONBody struct {
	Author      *string `json:"author,omitempty"`
	CoverGbid   *string `json:"cover_gbid,omitempty"`
	Description *string `json:"description,omitempty"`
	Isbn10      *string `json:"isbn10,omitempty"`
	Isbn13      *string `json:"isbn13,omitempty"`
	Title       *string `json:"title,omitempty"`
}

// UploadDocumentCoverMultipartBody defines parameters for UploadDocumentCover.
type UploadDocumentCoverMultipartBody struct {
	CoverFile openapi_types.File `json:"cover_file"`
}

// GetProgressListParams defines parameters for GetProgressList.
type GetProgressListParams struct {
	Page     *int64  `form:"page,omitempty" json:"page,omitempty"`
	Limit    *int64  `form:"limit,omitempty" json:"limit,omitempty"`
	Document *string `form:"document,omitempty" json:"document,omitempty"`
}

// GetSearchParams defines parameters for GetSearch.
type GetSearchParams struct {
	Query  string                `form:"query" json:"query"`
	Source GetSearchParamsSource `form:"source" json:"source"`
}

// GetSearchParamsSource defines parameters for GetSearch.
type GetSearchParamsSource string

// PostSearchFormdataBody defines parameters for PostSearch.
type PostSearchFormdataBody struct {
	Author string `form:"author" json:"author"`
	Id     string `form:"id" json:"id"`
	Source string `form:"source" json:"source"`
	Title  string `form:"title" json:"title"`
}

// PostAdminActionMultipartRequestBody defines body for PostAdminAction for multipart/form-data ContentType.
type PostAdminActionMultipartRequestBody PostAdminActionMultipartBody

// PostImportFormdataRequestBody defines body for PostImport for application/x-www-form-urlencoded ContentType.
type PostImportFormdataRequestBody PostImportFormdataBody

// UpdateUserFormdataRequestBody defines body for UpdateUser for application/x-www-form-urlencoded ContentType.
type UpdateUserFormdataRequestBody UpdateUserFormdataBody

// LoginJSONRequestBody defines body for Login for application/json ContentType.
type LoginJSONRequestBody = LoginRequest

// RegisterJSONRequestBody defines body for Register for application/json ContentType.
type RegisterJSONRequestBody = LoginRequest

// CreateDocumentMultipartRequestBody defines body for CreateDocument for multipart/form-data ContentType.
type CreateDocumentMultipartRequestBody CreateDocumentMultipartBody

// EditDocumentJSONRequestBody defines body for EditDocument for application/json ContentType.
type EditDocumentJSONRequestBody EditDocumentJSONBody

// UploadDocumentCoverMultipartRequestBody defines body for UploadDocumentCover for multipart/form-data ContentType.
type UploadDocumentCoverMultipartRequestBody UploadDocumentCoverMultipartBody

// PostSearchFormdataRequestBody defines body for PostSearch for application/x-www-form-urlencoded ContentType.
type PostSearchFormdataRequestBody PostSearchFormdataBody

// UpdateSettingsJSONRequestBody defines body for UpdateSettings for application/json ContentType.
type UpdateSettingsJSONRequestBody = UpdateSettingsRequest

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Get activity data
	// (GET /activity)
	GetActivity(w http.ResponseWriter, r *http.Request, params GetActivityParams)
	// Get admin page data
	// (GET /admin)
	GetAdmin(w http.ResponseWriter, r *http.Request)
	// Perform admin action (backup, restore, etc.)
	// (POST /admin)
	PostAdminAction(w http.ResponseWriter, r *http.Request)
	// Get import directory list
	// (GET /admin/import)
	GetImportDirectory(w http.ResponseWriter, r *http.Request, params GetImportDirectoryParams)
	// Perform import
	// (POST /admin/import)
	PostImport(w http.ResponseWriter, r *http.Request)
	// Get import results
	// (GET /admin/import-results)
	GetImportResults(w http.ResponseWriter, r *http.Request)
	// Get logs with optional filter
	// (GET /admin/logs)
	GetLogs(w http.ResponseWriter, r *http.Request, params GetLogsParams)
	// Get all users
	// (GET /admin/users)
	GetUsers(w http.ResponseWriter, r *http.Request)
	// Create, update, or delete user
	// (POST /admin/users)
	UpdateUser(w http.ResponseWriter, r *http.Request)
	// User login
	// (POST /auth/login)
	Login(w http.ResponseWriter, r *http.Request)
	// User logout
	// (POST /auth/logout)
	Logout(w http.ResponseWriter, r *http.Request)
	// Get current user info
	// (GET /auth/me)
	GetMe(w http.ResponseWriter, r *http.Request)
	// User registration
	// (POST /auth/register)
	Register(w http.ResponseWriter, r *http.Request)
	// List documents
	// (GET /documents)
	GetDocuments(w http.ResponseWriter, r *http.Request, params GetDocumentsParams)
	// Upload a new document
	// (POST /documents)
	CreateDocument(w http.ResponseWriter, r *http.Request)
	// Get a single document
	// (GET /documents/{id})
	GetDocument(w http.ResponseWriter, r *http.Request, id string)
	// Update document editable fields
	// (POST /documents/{id})
	EditDocument(w http.ResponseWriter, r *http.Request, id string)
	// Get document cover image
	// (GET /documents/{id}/cover)
	GetDocumentCover(w http.ResponseWriter, r *http.Request, id string)
	// Upload document cover image
	// (POST /documents/{id}/cover)
	UploadDocumentCover(w http.ResponseWriter, r *http.Request, id string)
	// Download document file
	// (GET /documents/{id}/file)
	GetDocumentFile(w http.ResponseWriter, r *http.Request, id string)
	// Get home page data
	// (GET /home)
	GetHome(w http.ResponseWriter, r *http.Request)
	// Get daily read stats graph data
	// (GET /home/graph)
	GetGraphData(w http.ResponseWriter, r *http.Request)
	// Get user statistics (leaderboards)
	// (GET /home/statistics)
	GetUserStatistics(w http.ResponseWriter, r *http.Request)
	// Get user streaks
	// (GET /home/streaks)
	GetStreaks(w http.ResponseWriter, r *http.Request)
	// Get server information
	// (GET /info)
	GetInfo(w http.ResponseWriter, r *http.Request)
	// List progress records
	// (GET /progress)
	GetProgressList(w http.ResponseWriter, r *http.Request, params GetProgressListParams)
	// Get document progress
	// (GET /progress/{id})
	GetProgress(w http.ResponseWriter, r *http.Request, id string)
	// Search external book sources
	// (GET /search)
	GetSearch(w http.ResponseWriter, r *http.Request, params GetSearchParams)
	// Download search result
	// (POST /search)
	PostSearch(w http.ResponseWriter, r *http.Request)
	// Get user settings
	// (GET /settings)
	GetSettings(w http.ResponseWriter, r *http.Request)
	// Update user settings
	// (PUT /settings)
	UpdateSettings(w http.ResponseWriter, r *http.Request)
}

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

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

	var err error

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "doc_filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "doc_filter", r.URL.Query(), &params.DocFilter, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "doc_filter", Err: err})
		return
	}

	// ------------- Optional query parameter "document_id" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "document_id", r.URL.Query(), &params.DocumentId, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "document_id", Err: err})
		return
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "offset", r.URL.Query(), &params.Offset, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "offset", Err: err})
		return
	}

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

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

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "directory" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "directory", r.URL.Query(), &params.Directory, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "directory", Err: err})
		return
	}

	// ------------- Optional query parameter "select" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "select", r.URL.Query(), &params.Select, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "select", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", r.URL.Query(), &params.Filter, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter", Err: err})
		return
	}

	// ------------- Optional query parameter "page" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "page", r.URL.Query(), &params.Page, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
		return
	}

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

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

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "page" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "page", r.URL.Query(), &params.Page, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
		return
	}

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

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

	// ------------- Optional query parameter "search" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "search", r.URL.Query(), &params.Search, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "search", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

	// ------------- Optional query parameter "page" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "page", r.URL.Query(), &params.Page, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page", Err: err})
		return
	}

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

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

	// ------------- Optional query parameter "document" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "document", r.URL.Query(), &params.Document, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "document", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	// ------------- Path parameter "id" -------------
	var id string

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	var err error

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	if paramValue := r.URL.Query().Get("query"); paramValue != "" {

	} else {
		siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "query"})
		return
	}

	err = runtime.BindQueryParameterWithOptions("form", true, true, "query", r.URL.Query(), &params.Query, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "query", Err: err})
		return
	}

	// ------------- Required query parameter "source" -------------

	if paramValue := r.URL.Query().Get("source"); paramValue != "" {

	} else {
		siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "source"})
		return
	}

	err = runtime.BindQueryParameterWithOptions("form", true, true, "source", r.URL.Query(), &params.Source, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "source", Err: err})
		return
	}

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

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

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

	handler.ServeHTTP(w, r)
}

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

	ctx := r.Context()

	ctx = context.WithValue(ctx, BearerAuthScopes, []string{})

	r = r.WithContext(ctx)

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.UpdateSettings(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, StdHTTPServerOptions{})
}

// ServeMux is an abstraction of http.ServeMux.
type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	ServeHTTP(w http.ResponseWriter, r *http.Request)
}

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("GET "+options.BaseURL+"/activity", wrapper.GetActivity)
	m.HandleFunc("GET "+options.BaseURL+"/admin", wrapper.GetAdmin)
	m.HandleFunc("POST "+options.BaseURL+"/admin", wrapper.PostAdminAction)
	m.HandleFunc("GET "+options.BaseURL+"/admin/import", wrapper.GetImportDirectory)
	m.HandleFunc("POST "+options.BaseURL+"/admin/import", wrapper.PostImport)
	m.HandleFunc("GET "+options.BaseURL+"/admin/import-results", wrapper.GetImportResults)
	m.HandleFunc("GET "+options.BaseURL+"/admin/logs", wrapper.GetLogs)
	m.HandleFunc("GET "+options.BaseURL+"/admin/users", wrapper.GetUsers)
	m.HandleFunc("POST "+options.BaseURL+"/admin/users", wrapper.UpdateUser)
	m.HandleFunc("POST "+options.BaseURL+"/auth/login", wrapper.Login)
	m.HandleFunc("POST "+options.BaseURL+"/auth/logout", wrapper.Logout)
	m.HandleFunc("GET "+options.BaseURL+"/auth/me", wrapper.GetMe)
	m.HandleFunc("POST "+options.BaseURL+"/auth/register", wrapper.Register)
	m.HandleFunc("GET "+options.BaseURL+"/documents", wrapper.GetDocuments)
	m.HandleFunc("POST "+options.BaseURL+"/documents", wrapper.CreateDocument)
	m.HandleFunc("GET "+options.BaseURL+"/documents/{id}", wrapper.GetDocument)
	m.HandleFunc("POST "+options.BaseURL+"/documents/{id}", wrapper.EditDocument)
	m.HandleFunc("GET "+options.BaseURL+"/documents/{id}/cover", wrapper.GetDocumentCover)
	m.HandleFunc("POST "+options.BaseURL+"/documents/{id}/cover", wrapper.UploadDocumentCover)
	m.HandleFunc("GET "+options.BaseURL+"/documents/{id}/file", wrapper.GetDocumentFile)
	m.HandleFunc("GET "+options.BaseURL+"/home", wrapper.GetHome)
	m.HandleFunc("GET "+options.BaseURL+"/home/graph", wrapper.GetGraphData)
	m.HandleFunc("GET "+options.BaseURL+"/home/statistics", wrapper.GetUserStatistics)
	m.HandleFunc("GET "+options.BaseURL+"/home/streaks", wrapper.GetStreaks)
	m.HandleFunc("GET "+options.BaseURL+"/info", wrapper.GetInfo)
	m.HandleFunc("GET "+options.BaseURL+"/progress", wrapper.GetProgressList)
	m.HandleFunc("GET "+options.BaseURL+"/progress/{id}", wrapper.GetProgress)
	m.HandleFunc("GET "+options.BaseURL+"/search", wrapper.GetSearch)
	m.HandleFunc("POST "+options.BaseURL+"/search", wrapper.PostSearch)
	m.HandleFunc("GET "+options.BaseURL+"/settings", wrapper.GetSettings)
	m.HandleFunc("PUT "+options.BaseURL+"/settings", wrapper.UpdateSettings)

	return m
}

type GetActivityRequestObject struct {
	Params GetActivityParams
}

type GetActivityResponseObject interface {
	VisitGetActivityResponse(w http.ResponseWriter) error
}

type GetActivity200JSONResponse ActivityResponse

func (response GetActivity200JSONResponse) VisitGetActivityResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetActivity401JSONResponse ErrorResponse

func (response GetActivity401JSONResponse) VisitGetActivityResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetActivity500JSONResponse ErrorResponse

func (response GetActivity500JSONResponse) VisitGetActivityResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetAdminRequestObject struct {
}

type GetAdminResponseObject interface {
	VisitGetAdminResponse(w http.ResponseWriter) error
}

type GetAdmin200JSONResponse struct {
	DatabaseInfo *DatabaseInfo `json:"database_info,omitempty"`
}

func (response GetAdmin200JSONResponse) VisitGetAdminResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetAdmin401JSONResponse ErrorResponse

func (response GetAdmin401JSONResponse) VisitGetAdminResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type PostAdminActionRequestObject struct {
	Body *multipart.Reader
}

type PostAdminActionResponseObject interface {
	VisitPostAdminActionResponse(w http.ResponseWriter) error
}

type PostAdminAction200JSONResponse MessageResponse

func (response PostAdminAction200JSONResponse) VisitPostAdminActionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type PostAdminAction200ApplicationoctetStreamResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response PostAdminAction200ApplicationoctetStreamResponse) VisitPostAdminActionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/octet-stream")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type PostAdminAction400JSONResponse ErrorResponse

func (response PostAdminAction400JSONResponse) VisitPostAdminActionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type PostAdminAction401JSONResponse ErrorResponse

func (response PostAdminAction401JSONResponse) VisitPostAdminActionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type PostAdminAction500JSONResponse ErrorResponse

func (response PostAdminAction500JSONResponse) VisitPostAdminActionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetImportDirectoryRequestObject struct {
	Params GetImportDirectoryParams
}

type GetImportDirectoryResponseObject interface {
	VisitGetImportDirectoryResponse(w http.ResponseWriter) error
}

type GetImportDirectory200JSONResponse DirectoryListResponse

func (response GetImportDirectory200JSONResponse) VisitGetImportDirectoryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetImportDirectory401JSONResponse ErrorResponse

func (response GetImportDirectory401JSONResponse) VisitGetImportDirectoryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetImportDirectory500JSONResponse ErrorResponse

func (response GetImportDirectory500JSONResponse) VisitGetImportDirectoryResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type PostImportRequestObject struct {
	Body *PostImportFormdataRequestBody
}

type PostImportResponseObject interface {
	VisitPostImportResponse(w http.ResponseWriter) error
}

type PostImport200JSONResponse ImportResultsResponse

func (response PostImport200JSONResponse) VisitPostImportResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type PostImport400JSONResponse ErrorResponse

func (response PostImport400JSONResponse) VisitPostImportResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type PostImport401JSONResponse ErrorResponse

func (response PostImport401JSONResponse) VisitPostImportResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type PostImport500JSONResponse ErrorResponse

func (response PostImport500JSONResponse) VisitPostImportResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetImportResultsRequestObject struct {
}

type GetImportResultsResponseObject interface {
	VisitGetImportResultsResponse(w http.ResponseWriter) error
}

type GetImportResults200JSONResponse ImportResultsResponse

func (response GetImportResults200JSONResponse) VisitGetImportResultsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetImportResults401JSONResponse ErrorResponse

func (response GetImportResults401JSONResponse) VisitGetImportResultsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetImportResults500JSONResponse ErrorResponse

func (response GetImportResults500JSONResponse) VisitGetImportResultsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetLogsRequestObject struct {
	Params GetLogsParams
}

type GetLogsResponseObject interface {
	VisitGetLogsResponse(w http.ResponseWriter) error
}

type GetLogs200JSONResponse LogsResponse

func (response GetLogs200JSONResponse) VisitGetLogsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetLogs401JSONResponse ErrorResponse

func (response GetLogs401JSONResponse) VisitGetLogsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetLogs500JSONResponse ErrorResponse

func (response GetLogs500JSONResponse) VisitGetLogsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetUsersRequestObject struct {
}

type GetUsersResponseObject interface {
	VisitGetUsersResponse(w http.ResponseWriter) error
}

type GetUsers200JSONResponse UsersResponse

func (response GetUsers200JSONResponse) VisitGetUsersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetUsers401JSONResponse ErrorResponse

func (response GetUsers401JSONResponse) VisitGetUsersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetUsers500JSONResponse ErrorResponse

func (response GetUsers500JSONResponse) VisitGetUsersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type UpdateUserRequestObject struct {
	Body *UpdateUserFormdataRequestBody
}

type UpdateUserResponseObject interface {
	VisitUpdateUserResponse(w http.ResponseWriter) error
}

type UpdateUser200JSONResponse UsersResponse

func (response UpdateUser200JSONResponse) VisitUpdateUserResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type UpdateUser400JSONResponse ErrorResponse

func (response UpdateUser400JSONResponse) VisitUpdateUserResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type UpdateUser401JSONResponse ErrorResponse

func (response UpdateUser401JSONResponse) VisitUpdateUserResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type UpdateUser500JSONResponse ErrorResponse

func (response UpdateUser500JSONResponse) VisitUpdateUserResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type LoginRequestObject struct {
	Body *LoginJSONRequestBody
}

type LoginResponseObject interface {
	VisitLoginResponse(w http.ResponseWriter) error
}

type Login200JSONResponse LoginResponse

func (response Login200JSONResponse) VisitLoginResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type Login400JSONResponse ErrorResponse

func (response Login400JSONResponse) VisitLoginResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type Login401JSONResponse ErrorResponse

func (response Login401JSONResponse) VisitLoginResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type Login500JSONResponse ErrorResponse

func (response Login500JSONResponse) VisitLoginResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type LogoutRequestObject struct {
}

type LogoutResponseObject interface {
	VisitLogoutResponse(w http.ResponseWriter) error
}

type Logout200Response struct {
}

func (response Logout200Response) VisitLogoutResponse(w http.ResponseWriter) error {
	w.WriteHeader(200)
	return nil
}

type Logout401JSONResponse ErrorResponse

func (response Logout401JSONResponse) VisitLogoutResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetMeRequestObject struct {
}

type GetMeResponseObject interface {
	VisitGetMeResponse(w http.ResponseWriter) error
}

type GetMe200JSONResponse LoginResponse

func (response GetMe200JSONResponse) VisitGetMeResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetMe401JSONResponse ErrorResponse

func (response GetMe401JSONResponse) VisitGetMeResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type RegisterRequestObject struct {
	Body *RegisterJSONRequestBody
}

type RegisterResponseObject interface {
	VisitRegisterResponse(w http.ResponseWriter) error
}

type Register201JSONResponse LoginResponse

func (response Register201JSONResponse) VisitRegisterResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)

	return json.NewEncoder(w).Encode(response)
}

type Register400JSONResponse ErrorResponse

func (response Register400JSONResponse) VisitRegisterResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type Register403JSONResponse ErrorResponse

func (response Register403JSONResponse) VisitRegisterResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

	return json.NewEncoder(w).Encode(response)
}

type Register500JSONResponse ErrorResponse

func (response Register500JSONResponse) VisitRegisterResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentsRequestObject struct {
	Params GetDocumentsParams
}

type GetDocumentsResponseObject interface {
	VisitGetDocumentsResponse(w http.ResponseWriter) error
}

type GetDocuments200JSONResponse DocumentsResponse

func (response GetDocuments200JSONResponse) VisitGetDocumentsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetDocuments401JSONResponse ErrorResponse

func (response GetDocuments401JSONResponse) VisitGetDocumentsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDocuments500JSONResponse ErrorResponse

func (response GetDocuments500JSONResponse) VisitGetDocumentsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type CreateDocumentRequestObject struct {
	Body *multipart.Reader
}

type CreateDocumentResponseObject interface {
	VisitCreateDocumentResponse(w http.ResponseWriter) error
}

type CreateDocument200JSONResponse DocumentResponse

func (response CreateDocument200JSONResponse) VisitCreateDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type CreateDocument400JSONResponse ErrorResponse

func (response CreateDocument400JSONResponse) VisitCreateDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type CreateDocument401JSONResponse ErrorResponse

func (response CreateDocument401JSONResponse) VisitCreateDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type CreateDocument500JSONResponse ErrorResponse

func (response CreateDocument500JSONResponse) VisitCreateDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentRequestObject struct {
	Id string `json:"id"`
}

type GetDocumentResponseObject interface {
	VisitGetDocumentResponse(w http.ResponseWriter) error
}

type GetDocument200JSONResponse DocumentResponse

func (response GetDocument200JSONResponse) VisitGetDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetDocument401JSONResponse ErrorResponse

func (response GetDocument401JSONResponse) VisitGetDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDocument404JSONResponse ErrorResponse

func (response GetDocument404JSONResponse) VisitGetDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDocument500JSONResponse ErrorResponse

func (response GetDocument500JSONResponse) VisitGetDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type EditDocumentRequestObject struct {
	Id   string `json:"id"`
	Body *EditDocumentJSONRequestBody
}

type EditDocumentResponseObject interface {
	VisitEditDocumentResponse(w http.ResponseWriter) error
}

type EditDocument200JSONResponse DocumentResponse

func (response EditDocument200JSONResponse) VisitEditDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type EditDocument400JSONResponse ErrorResponse

func (response EditDocument400JSONResponse) VisitEditDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type EditDocument401JSONResponse ErrorResponse

func (response EditDocument401JSONResponse) VisitEditDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type EditDocument404JSONResponse ErrorResponse

func (response EditDocument404JSONResponse) VisitEditDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type EditDocument500JSONResponse ErrorResponse

func (response EditDocument500JSONResponse) VisitEditDocumentResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentCoverRequestObject struct {
	Id string `json:"id"`
}

type GetDocumentCoverResponseObject interface {
	VisitGetDocumentCoverResponse(w http.ResponseWriter) error
}

type GetDocumentCover200ImagejpegResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response GetDocumentCover200ImagejpegResponse) VisitGetDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "image/jpeg")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type GetDocumentCover200ImagepngResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response GetDocumentCover200ImagepngResponse) VisitGetDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "image/png")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type GetDocumentCover401JSONResponse ErrorResponse

func (response GetDocumentCover401JSONResponse) VisitGetDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentCover404JSONResponse ErrorResponse

func (response GetDocumentCover404JSONResponse) VisitGetDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentCover500JSONResponse ErrorResponse

func (response GetDocumentCover500JSONResponse) VisitGetDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type UploadDocumentCoverRequestObject struct {
	Id   string `json:"id"`
	Body *multipart.Reader
}

type UploadDocumentCoverResponseObject interface {
	VisitUploadDocumentCoverResponse(w http.ResponseWriter) error
}

type UploadDocumentCover200JSONResponse DocumentResponse

func (response UploadDocumentCover200JSONResponse) VisitUploadDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type UploadDocumentCover400JSONResponse ErrorResponse

func (response UploadDocumentCover400JSONResponse) VisitUploadDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type UploadDocumentCover401JSONResponse ErrorResponse

func (response UploadDocumentCover401JSONResponse) VisitUploadDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type UploadDocumentCover404JSONResponse ErrorResponse

func (response UploadDocumentCover404JSONResponse) VisitUploadDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type UploadDocumentCover500JSONResponse ErrorResponse

func (response UploadDocumentCover500JSONResponse) VisitUploadDocumentCoverResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentFileRequestObject struct {
	Id string `json:"id"`
}

type GetDocumentFileResponseObject interface {
	VisitGetDocumentFileResponse(w http.ResponseWriter) error
}

type GetDocumentFile200ApplicationoctetStreamResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response GetDocumentFile200ApplicationoctetStreamResponse) VisitGetDocumentFileResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/octet-stream")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type GetDocumentFile401JSONResponse ErrorResponse

func (response GetDocumentFile401JSONResponse) VisitGetDocumentFileResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentFile404JSONResponse ErrorResponse

func (response GetDocumentFile404JSONResponse) VisitGetDocumentFileResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetDocumentFile500JSONResponse ErrorResponse

func (response GetDocumentFile500JSONResponse) VisitGetDocumentFileResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetHomeRequestObject struct {
}

type GetHomeResponseObject interface {
	VisitGetHomeResponse(w http.ResponseWriter) error
}

type GetHome200JSONResponse HomeResponse

func (response GetHome200JSONResponse) VisitGetHomeResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetHome401JSONResponse ErrorResponse

func (response GetHome401JSONResponse) VisitGetHomeResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetHome500JSONResponse ErrorResponse

func (response GetHome500JSONResponse) VisitGetHomeResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetGraphDataRequestObject struct {
}

type GetGraphDataResponseObject interface {
	VisitGetGraphDataResponse(w http.ResponseWriter) error
}

type GetGraphData200JSONResponse GraphDataResponse

func (response GetGraphData200JSONResponse) VisitGetGraphDataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetGraphData401JSONResponse ErrorResponse

func (response GetGraphData401JSONResponse) VisitGetGraphDataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetGraphData500JSONResponse ErrorResponse

func (response GetGraphData500JSONResponse) VisitGetGraphDataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetUserStatisticsRequestObject struct {
}

type GetUserStatisticsResponseObject interface {
	VisitGetUserStatisticsResponse(w http.ResponseWriter) error
}

type GetUserStatistics200JSONResponse UserStatisticsResponse

func (response GetUserStatistics200JSONResponse) VisitGetUserStatisticsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetUserStatistics401JSONResponse ErrorResponse

func (response GetUserStatistics401JSONResponse) VisitGetUserStatisticsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetUserStatistics500JSONResponse ErrorResponse

func (response GetUserStatistics500JSONResponse) VisitGetUserStatisticsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetStreaksRequestObject struct {
}

type GetStreaksResponseObject interface {
	VisitGetStreaksResponse(w http.ResponseWriter) error
}

type GetStreaks200JSONResponse StreaksResponse

func (response GetStreaks200JSONResponse) VisitGetStreaksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetStreaks401JSONResponse ErrorResponse

func (response GetStreaks401JSONResponse) VisitGetStreaksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetStreaks500JSONResponse ErrorResponse

func (response GetStreaks500JSONResponse) VisitGetStreaksResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetInfoRequestObject struct {
}

type GetInfoResponseObject interface {
	VisitGetInfoResponse(w http.ResponseWriter) error
}

type GetInfo200JSONResponse InfoResponse

func (response GetInfo200JSONResponse) VisitGetInfoResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetInfo500JSONResponse ErrorResponse

func (response GetInfo500JSONResponse) VisitGetInfoResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetProgressListRequestObject struct {
	Params GetProgressListParams
}

type GetProgressListResponseObject interface {
	VisitGetProgressListResponse(w http.ResponseWriter) error
}

type GetProgressList200JSONResponse ProgressListResponse

func (response GetProgressList200JSONResponse) VisitGetProgressListResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetProgressList401JSONResponse ErrorResponse

func (response GetProgressList401JSONResponse) VisitGetProgressListResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetProgressList500JSONResponse ErrorResponse

func (response GetProgressList500JSONResponse) VisitGetProgressListResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetProgressRequestObject struct {
	Id string `json:"id"`
}

type GetProgressResponseObject interface {
	VisitGetProgressResponse(w http.ResponseWriter) error
}

type GetProgress200JSONResponse ProgressResponse

func (response GetProgress200JSONResponse) VisitGetProgressResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetProgress401JSONResponse ErrorResponse

func (response GetProgress401JSONResponse) VisitGetProgressResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetProgress404JSONResponse ErrorResponse

func (response GetProgress404JSONResponse) VisitGetProgressResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

	return json.NewEncoder(w).Encode(response)
}

type GetProgress500JSONResponse ErrorResponse

func (response GetProgress500JSONResponse) VisitGetProgressResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetSearchRequestObject struct {
	Params GetSearchParams
}

type GetSearchResponseObject interface {
	VisitGetSearchResponse(w http.ResponseWriter) error
}

type GetSearch200JSONResponse SearchResponse

func (response GetSearch200JSONResponse) VisitGetSearchResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetSearch400JSONResponse ErrorResponse

func (response GetSearch400JSONResponse) VisitGetSearchResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type GetSearch401JSONResponse ErrorResponse

func (response GetSearch401JSONResponse) VisitGetSearchResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetSearch500JSONResponse ErrorResponse

func (response GetSearch500JSONResponse) VisitGetSearchResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type PostSearchRequestObject struct {
	Body *PostSearchFormdataRequestBody
}

type PostSearchResponseObject interface {
	VisitPostSearchResponse(w http.ResponseWriter) error
}

type PostSearch200Response struct {
}

func (response PostSearch200Response) VisitPostSearchResponse(w http.ResponseWriter) error {
	w.WriteHeader(200)
	return nil
}

type PostSearch401JSONResponse ErrorResponse

func (response PostSearch401JSONResponse) VisitPostSearchResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type PostSearch500JSONResponse ErrorResponse

func (response PostSearch500JSONResponse) VisitPostSearchResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type GetSettingsRequestObject struct {
}

type GetSettingsResponseObject interface {
	VisitGetSettingsResponse(w http.ResponseWriter) error
}

type GetSettings200JSONResponse SettingsResponse

func (response GetSettings200JSONResponse) VisitGetSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetSettings401JSONResponse ErrorResponse

func (response GetSettings401JSONResponse) VisitGetSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type GetSettings500JSONResponse ErrorResponse

func (response GetSettings500JSONResponse) VisitGetSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

type UpdateSettingsRequestObject struct {
	Body *UpdateSettingsJSONRequestBody
}

type UpdateSettingsResponseObject interface {
	VisitUpdateSettingsResponse(w http.ResponseWriter) error
}

type UpdateSettings200JSONResponse SettingsResponse

func (response UpdateSettings200JSONResponse) VisitUpdateSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type UpdateSettings400JSONResponse ErrorResponse

func (response UpdateSettings400JSONResponse) VisitUpdateSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

	return json.NewEncoder(w).Encode(response)
}

type UpdateSettings401JSONResponse ErrorResponse

func (response UpdateSettings401JSONResponse) VisitUpdateSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

	return json.NewEncoder(w).Encode(response)
}

type UpdateSettings500JSONResponse ErrorResponse

func (response UpdateSettings500JSONResponse) VisitUpdateSettingsResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(500)

	return json.NewEncoder(w).Encode(response)
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// Get activity data
	// (GET /activity)
	GetActivity(ctx context.Context, request GetActivityRequestObject) (GetActivityResponseObject, error)
	// Get admin page data
	// (GET /admin)
	GetAdmin(ctx context.Context, request GetAdminRequestObject) (GetAdminResponseObject, error)
	// Perform admin action (backup, restore, etc.)
	// (POST /admin)
	PostAdminAction(ctx context.Context, request PostAdminActionRequestObject) (PostAdminActionResponseObject, error)
	// Get import directory list
	// (GET /admin/import)
	GetImportDirectory(ctx context.Context, request GetImportDirectoryRequestObject) (GetImportDirectoryResponseObject, error)
	// Perform import
	// (POST /admin/import)
	PostImport(ctx context.Context, request PostImportRequestObject) (PostImportResponseObject, error)
	// Get import results
	// (GET /admin/import-results)
	GetImportResults(ctx context.Context, request GetImportResultsRequestObject) (GetImportResultsResponseObject, error)
	// Get logs with optional filter
	// (GET /admin/logs)
	GetLogs(ctx context.Context, request GetLogsRequestObject) (GetLogsResponseObject, error)
	// Get all users
	// (GET /admin/users)
	GetUsers(ctx context.Context, request GetUsersRequestObject) (GetUsersResponseObject, error)
	// Create, update, or delete user
	// (POST /admin/users)
	UpdateUser(ctx context.Context, request UpdateUserRequestObject) (UpdateUserResponseObject, error)
	// User login
	// (POST /auth/login)
	Login(ctx context.Context, request LoginRequestObject) (LoginResponseObject, error)
	// User logout
	// (POST /auth/logout)
	Logout(ctx context.Context, request LogoutRequestObject) (LogoutResponseObject, error)
	// Get current user info
	// (GET /auth/me)
	GetMe(ctx context.Context, request GetMeRequestObject) (GetMeResponseObject, error)
	// User registration
	// (POST /auth/register)
	Register(ctx context.Context, request RegisterRequestObject) (RegisterResponseObject, error)
	// List documents
	// (GET /documents)
	GetDocuments(ctx context.Context, request GetDocumentsRequestObject) (GetDocumentsResponseObject, error)
	// Upload a new document
	// (POST /documents)
	CreateDocument(ctx context.Context, request CreateDocumentRequestObject) (CreateDocumentResponseObject, error)
	// Get a single document
	// (GET /documents/{id})
	GetDocument(ctx context.Context, request GetDocumentRequestObject) (GetDocumentResponseObject, error)
	// Update document editable fields
	// (POST /documents/{id})
	EditDocument(ctx context.Context, request EditDocumentRequestObject) (EditDocumentResponseObject, error)
	// Get document cover image
	// (GET /documents/{id}/cover)
	GetDocumentCover(ctx context.Context, request GetDocumentCoverRequestObject) (GetDocumentCoverResponseObject, error)
	// Upload document cover image
	// (POST /documents/{id}/cover)
	UploadDocumentCover(ctx context.Context, request UploadDocumentCoverRequestObject) (UploadDocumentCoverResponseObject, error)
	// Download document file
	// (GET /documents/{id}/file)
	GetDocumentFile(ctx context.Context, request GetDocumentFileRequestObject) (GetDocumentFileResponseObject, error)
	// Get home page data
	// (GET /home)
	GetHome(ctx context.Context, request GetHomeRequestObject) (GetHomeResponseObject, error)
	// Get daily read stats graph data
	// (GET /home/graph)
	GetGraphData(ctx context.Context, request GetGraphDataRequestObject) (GetGraphDataResponseObject, error)
	// Get user statistics (leaderboards)
	// (GET /home/statistics)
	GetUserStatistics(ctx context.Context, request GetUserStatisticsRequestObject) (GetUserStatisticsResponseObject, error)
	// Get user streaks
	// (GET /home/streaks)
	GetStreaks(ctx context.Context, request GetStreaksRequestObject) (GetStreaksResponseObject, error)
	// Get server information
	// (GET /info)
	GetInfo(ctx context.Context, request GetInfoRequestObject) (GetInfoResponseObject, error)
	// List progress records
	// (GET /progress)
	GetProgressList(ctx context.Context, request GetProgressListRequestObject) (GetProgressListResponseObject, error)
	// Get document progress
	// (GET /progress/{id})
	GetProgress(ctx context.Context, request GetProgressRequestObject) (GetProgressResponseObject, error)
	// Search external book sources
	// (GET /search)
	GetSearch(ctx context.Context, request GetSearchRequestObject) (GetSearchResponseObject, error)
	// Download search result
	// (POST /search)
	PostSearch(ctx context.Context, request PostSearchRequestObject) (PostSearchResponseObject, error)
	// Get user settings
	// (GET /settings)
	GetSettings(ctx context.Context, request GetSettingsRequestObject) (GetSettingsResponseObject, error)
	// Update user settings
	// (PUT /settings)
	UpdateSettings(ctx context.Context, request UpdateSettingsRequestObject) (UpdateSettingsResponseObject, error)
}

type StrictHandlerFunc = strictnethttp.StrictHTTPHandlerFunc
type StrictMiddlewareFunc = strictnethttp.StrictHTTPMiddlewareFunc

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 {
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
	options     StrictHTTPServerOptions
}

// GetActivity operation middleware
func (sh *strictHandler) GetActivity(w http.ResponseWriter, r *http.Request, params GetActivityParams) {
	var request GetActivityRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetActivity(ctx, request.(GetActivityRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetActivity")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetActivityResponseObject); ok {
		if err := validResponse.VisitGetActivityResponse(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))
	}
}

// GetAdmin operation middleware
func (sh *strictHandler) GetAdmin(w http.ResponseWriter, r *http.Request) {
	var request GetAdminRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetAdmin(ctx, request.(GetAdminRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAdmin")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetAdminResponseObject); ok {
		if err := validResponse.VisitGetAdminResponse(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))
	}
}

// PostAdminAction operation middleware
func (sh *strictHandler) PostAdminAction(w http.ResponseWriter, r *http.Request) {
	var request PostAdminActionRequestObject

	if reader, err := r.MultipartReader(); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode multipart body: %w", err))
		return
	} else {
		request.Body = reader
	}

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.PostAdminAction(ctx, request.(PostAdminActionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PostAdminAction")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(PostAdminActionResponseObject); ok {
		if err := validResponse.VisitPostAdminActionResponse(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))
	}
}

// GetImportDirectory operation middleware
func (sh *strictHandler) GetImportDirectory(w http.ResponseWriter, r *http.Request, params GetImportDirectoryParams) {
	var request GetImportDirectoryRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetImportDirectory(ctx, request.(GetImportDirectoryRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetImportDirectory")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetImportDirectoryResponseObject); ok {
		if err := validResponse.VisitGetImportDirectoryResponse(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))
	}
}

// PostImport operation middleware
func (sh *strictHandler) PostImport(w http.ResponseWriter, r *http.Request) {
	var request PostImportRequestObject

	if err := r.ParseForm(); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode formdata: %w", err))
		return
	}
	var body PostImportFormdataRequestBody
	if err := runtime.BindForm(&body, r.Form, nil, nil); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't bind formdata: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.PostImport(ctx, request.(PostImportRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PostImport")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(PostImportResponseObject); ok {
		if err := validResponse.VisitPostImportResponse(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))
	}
}

// GetImportResults operation middleware
func (sh *strictHandler) GetImportResults(w http.ResponseWriter, r *http.Request) {
	var request GetImportResultsRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetImportResults(ctx, request.(GetImportResultsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetImportResults")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetImportResultsResponseObject); ok {
		if err := validResponse.VisitGetImportResultsResponse(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))
	}
}

// GetLogs operation middleware
func (sh *strictHandler) GetLogs(w http.ResponseWriter, r *http.Request, params GetLogsParams) {
	var request GetLogsRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetLogs(ctx, request.(GetLogsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetLogs")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetLogsResponseObject); ok {
		if err := validResponse.VisitGetLogsResponse(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))
	}
}

// GetUsers operation middleware
func (sh *strictHandler) GetUsers(w http.ResponseWriter, r *http.Request) {
	var request GetUsersRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetUsers(ctx, request.(GetUsersRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUsers")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetUsersResponseObject); ok {
		if err := validResponse.VisitGetUsersResponse(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))
	}
}

// UpdateUser operation middleware
func (sh *strictHandler) UpdateUser(w http.ResponseWriter, r *http.Request) {
	var request UpdateUserRequestObject

	if err := r.ParseForm(); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode formdata: %w", err))
		return
	}
	var body UpdateUserFormdataRequestBody
	if err := runtime.BindForm(&body, r.Form, nil, nil); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't bind formdata: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateUser(ctx, request.(UpdateUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateUser")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(UpdateUserResponseObject); ok {
		if err := validResponse.VisitUpdateUserResponse(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))
	}
}

// Login operation middleware
func (sh *strictHandler) Login(w http.ResponseWriter, r *http.Request) {
	var request LoginRequestObject

	var body LoginJSONRequestBody
	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.Login(ctx, request.(LoginRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "Login")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(LoginResponseObject); ok {
		if err := validResponse.VisitLoginResponse(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))
	}
}

// Logout operation middleware
func (sh *strictHandler) Logout(w http.ResponseWriter, r *http.Request) {
	var request LogoutRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.Logout(ctx, request.(LogoutRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "Logout")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(LogoutResponseObject); ok {
		if err := validResponse.VisitLogoutResponse(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))
	}
}

// GetMe operation middleware
func (sh *strictHandler) GetMe(w http.ResponseWriter, r *http.Request) {
	var request GetMeRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetMe(ctx, request.(GetMeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetMe")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetMeResponseObject); ok {
		if err := validResponse.VisitGetMeResponse(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))
	}
}

// Register operation middleware
func (sh *strictHandler) Register(w http.ResponseWriter, r *http.Request) {
	var request RegisterRequestObject

	var body RegisterJSONRequestBody
	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.Register(ctx, request.(RegisterRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "Register")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(RegisterResponseObject); ok {
		if err := validResponse.VisitRegisterResponse(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))
	}
}

// GetDocuments operation middleware
func (sh *strictHandler) GetDocuments(w http.ResponseWriter, r *http.Request, params GetDocumentsParams) {
	var request GetDocumentsRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDocuments(ctx, request.(GetDocumentsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDocuments")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDocumentsResponseObject); ok {
		if err := validResponse.VisitGetDocumentsResponse(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))
	}
}

// CreateDocument operation middleware
func (sh *strictHandler) CreateDocument(w http.ResponseWriter, r *http.Request) {
	var request CreateDocumentRequestObject

	if reader, err := r.MultipartReader(); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode multipart body: %w", err))
		return
	} else {
		request.Body = reader
	}

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.CreateDocument(ctx, request.(CreateDocumentRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateDocument")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(CreateDocumentResponseObject); ok {
		if err := validResponse.VisitCreateDocumentResponse(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))
	}
}

// GetDocument operation middleware
func (sh *strictHandler) GetDocument(w http.ResponseWriter, r *http.Request, id string) {
	var request GetDocumentRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDocument(ctx, request.(GetDocumentRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDocument")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDocumentResponseObject); ok {
		if err := validResponse.VisitGetDocumentResponse(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))
	}
}

// EditDocument operation middleware
func (sh *strictHandler) EditDocument(w http.ResponseWriter, r *http.Request, id string) {
	var request EditDocumentRequestObject

	request.Id = id

	var body EditDocumentJSONRequestBody
	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.EditDocument(ctx, request.(EditDocumentRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "EditDocument")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(EditDocumentResponseObject); ok {
		if err := validResponse.VisitEditDocumentResponse(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))
	}
}

// GetDocumentCover operation middleware
func (sh *strictHandler) GetDocumentCover(w http.ResponseWriter, r *http.Request, id string) {
	var request GetDocumentCoverRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDocumentCover(ctx, request.(GetDocumentCoverRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDocumentCover")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDocumentCoverResponseObject); ok {
		if err := validResponse.VisitGetDocumentCoverResponse(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))
	}
}

// UploadDocumentCover operation middleware
func (sh *strictHandler) UploadDocumentCover(w http.ResponseWriter, r *http.Request, id string) {
	var request UploadDocumentCoverRequestObject

	request.Id = id

	if reader, err := r.MultipartReader(); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode multipart body: %w", err))
		return
	} else {
		request.Body = reader
	}

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.UploadDocumentCover(ctx, request.(UploadDocumentCoverRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UploadDocumentCover")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(UploadDocumentCoverResponseObject); ok {
		if err := validResponse.VisitUploadDocumentCoverResponse(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))
	}
}

// GetDocumentFile operation middleware
func (sh *strictHandler) GetDocumentFile(w http.ResponseWriter, r *http.Request, id string) {
	var request GetDocumentFileRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetDocumentFile(ctx, request.(GetDocumentFileRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetDocumentFile")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetDocumentFileResponseObject); ok {
		if err := validResponse.VisitGetDocumentFileResponse(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))
	}
}

// GetHome operation middleware
func (sh *strictHandler) GetHome(w http.ResponseWriter, r *http.Request) {
	var request GetHomeRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetHome(ctx, request.(GetHomeRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetHome")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetHomeResponseObject); ok {
		if err := validResponse.VisitGetHomeResponse(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))
	}
}

// GetGraphData operation middleware
func (sh *strictHandler) GetGraphData(w http.ResponseWriter, r *http.Request) {
	var request GetGraphDataRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetGraphData(ctx, request.(GetGraphDataRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetGraphData")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetGraphDataResponseObject); ok {
		if err := validResponse.VisitGetGraphDataResponse(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))
	}
}

// GetUserStatistics operation middleware
func (sh *strictHandler) GetUserStatistics(w http.ResponseWriter, r *http.Request) {
	var request GetUserStatisticsRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetUserStatistics(ctx, request.(GetUserStatisticsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUserStatistics")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetUserStatisticsResponseObject); ok {
		if err := validResponse.VisitGetUserStatisticsResponse(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))
	}
}

// GetStreaks operation middleware
func (sh *strictHandler) GetStreaks(w http.ResponseWriter, r *http.Request) {
	var request GetStreaksRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetStreaks(ctx, request.(GetStreaksRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetStreaks")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetStreaksResponseObject); ok {
		if err := validResponse.VisitGetStreaksResponse(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))
	}
}

// GetInfo operation middleware
func (sh *strictHandler) GetInfo(w http.ResponseWriter, r *http.Request) {
	var request GetInfoRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetInfo(ctx, request.(GetInfoRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetInfo")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetInfoResponseObject); ok {
		if err := validResponse.VisitGetInfoResponse(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))
	}
}

// GetProgressList operation middleware
func (sh *strictHandler) GetProgressList(w http.ResponseWriter, r *http.Request, params GetProgressListParams) {
	var request GetProgressListRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetProgressList(ctx, request.(GetProgressListRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetProgressList")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetProgressListResponseObject); ok {
		if err := validResponse.VisitGetProgressListResponse(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))
	}
}

// GetProgress operation middleware
func (sh *strictHandler) GetProgress(w http.ResponseWriter, r *http.Request, id string) {
	var request GetProgressRequestObject

	request.Id = id

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetProgress(ctx, request.(GetProgressRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetProgress")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetProgressResponseObject); ok {
		if err := validResponse.VisitGetProgressResponse(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))
	}
}

// GetSearch operation middleware
func (sh *strictHandler) GetSearch(w http.ResponseWriter, r *http.Request, params GetSearchParams) {
	var request GetSearchRequestObject

	request.Params = params

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetSearch(ctx, request.(GetSearchRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetSearch")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetSearchResponseObject); ok {
		if err := validResponse.VisitGetSearchResponse(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))
	}
}

// PostSearch operation middleware
func (sh *strictHandler) PostSearch(w http.ResponseWriter, r *http.Request) {
	var request PostSearchRequestObject

	if err := r.ParseForm(); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode formdata: %w", err))
		return
	}
	var body PostSearchFormdataRequestBody
	if err := runtime.BindForm(&body, r.Form, nil, nil); err != nil {
		sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't bind formdata: %w", err))
		return
	}
	request.Body = &body

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.PostSearch(ctx, request.(PostSearchRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PostSearch")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(PostSearchResponseObject); ok {
		if err := validResponse.VisitPostSearchResponse(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))
	}
}

// GetSettings operation middleware
func (sh *strictHandler) GetSettings(w http.ResponseWriter, r *http.Request) {
	var request GetSettingsRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetSettings(ctx, request.(GetSettingsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetSettings")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetSettingsResponseObject); ok {
		if err := validResponse.VisitGetSettingsResponse(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))
	}
}

// UpdateSettings operation middleware
func (sh *strictHandler) UpdateSettings(w http.ResponseWriter, r *http.Request) {
	var request UpdateSettingsRequestObject

	var body UpdateSettingsJSONRequestBody
	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.UpdateSettings(ctx, request.(UpdateSettingsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateSettings")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(UpdateSettingsResponseObject); ok {
		if err := validResponse.VisitUpdateSettingsResponse(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))
	}
}