path: root/backend/api/generated.go

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

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/labstack/echo/v4"
	"github.com/oapi-codegen/runtime"
	strictecho "github.com/oapi-codegen/runtime/strictmiddleware/echo"
)

// AddFeedRequest defines model for AddFeedRequest.
type AddFeedRequest struct {
	Url string `json:"url"`
}

// Article defines model for Article.
type Article struct {
	Feed   ArticleFeed `json:"feed"`
	FeedId string      `json:"feedId"`
	Guid   string      `json:"guid"`
	Id     string      `json:"id"`
	IsRead bool        `json:"isRead"`
	Title  string      `json:"title"`
	Url    string      `json:"url"`
}

// ArticleConnection defines model for ArticleConnection.
type ArticleConnection struct {
	Articles []Article `json:"articles"`
	PageInfo PageInfo  `json:"pageInfo"`
}

// ArticleFeed defines model for ArticleFeed.
type ArticleFeed struct {
	Id           string `json:"id"`
	IsSubscribed bool   `json:"isSubscribed"`
	Title        string `json:"title"`
	Url          string `json:"url"`
}

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

// Feed defines model for Feed.
type Feed struct {
	FetchedAt    string `json:"fetchedAt"`
	Id           string `json:"id"`
	IsSubscribed bool   `json:"isSubscribed"`
	Title        string `json:"title"`
	UnreadCount  int32  `json:"unreadCount"`
	Url          string `json:"url"`
}

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

// LoginResponse defines model for LoginResponse.
type LoginResponse struct {
	User User `json:"user"`
}

// PageInfo defines model for PageInfo.
type PageInfo struct {
	EndCursor   *string `json:"endCursor,omitempty"`
	HasNextPage bool    `json:"hasNextPage"`
}

// User defines model for User.
type User struct {
	Id       string `json:"id"`
	Username string `json:"username"`
}

// ArticlesListReadArticlesParams defines parameters for ArticlesListReadArticles.
type ArticlesListReadArticlesParams struct {
	FeedId *string `form:"feedId,omitempty" json:"feedId,omitempty"`
	After  *string `form:"after,omitempty" json:"after,omitempty"`
	First  *int32  `form:"first,omitempty" json:"first,omitempty"`
}

// ArticlesListUnreadArticlesParams defines parameters for ArticlesListUnreadArticles.
type ArticlesListUnreadArticlesParams struct {
	FeedId *string `form:"feedId,omitempty" json:"feedId,omitempty"`
	After  *string `form:"after,omitempty" json:"after,omitempty"`
	First  *int32  `form:"first,omitempty" json:"first,omitempty"`
}

// AuthLoginJSONRequestBody defines body for AuthLogin for application/json ContentType.
type AuthLoginJSONRequestBody = LoginRequest

// FeedsAddFeedJSONRequestBody defines body for FeedsAddFeed for application/json ContentType.
type FeedsAddFeedJSONRequestBody = AddFeedRequest

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

	// (GET /api/articles/read)
	ArticlesListReadArticles(ctx echo.Context, params ArticlesListReadArticlesParams) error

	// (GET /api/articles/unread)
	ArticlesListUnreadArticles(ctx echo.Context, params ArticlesListUnreadArticlesParams) error

	// (GET /api/articles/{articleId})
	ArticlesGetArticle(ctx echo.Context, articleId string) error

	// (POST /api/articles/{articleId}/read)
	ArticlesMarkArticleRead(ctx echo.Context, articleId string) error

	// (POST /api/articles/{articleId}/unread)
	ArticlesMarkArticleUnread(ctx echo.Context, articleId string) error

	// (POST /api/auth/login)
	AuthLogin(ctx echo.Context) error

	// (POST /api/auth/logout)
	AuthLogout(ctx echo.Context) error

	// (GET /api/auth/me)
	AuthGetCurrentUser(ctx echo.Context) error

	// (GET /api/feeds)
	FeedsListFeeds(ctx echo.Context) error

	// (POST /api/feeds)
	FeedsAddFeed(ctx echo.Context) error

	// (DELETE /api/feeds/{feedId})
	FeedsUnsubscribeFeed(ctx echo.Context, feedId string) error

	// (GET /api/feeds/{feedId})
	FeedsGetFeed(ctx echo.Context, feedId string) error

	// (POST /api/feeds/{feedId}/read)
	FeedsMarkFeedRead(ctx echo.Context, feedId string) error

	// (POST /api/feeds/{feedId}/unread)
	FeedsMarkFeedUnread(ctx echo.Context, feedId string) error
}

// ServerInterfaceWrapper converts echo contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler ServerInterface
}

// ArticlesListReadArticles converts echo context to params.
func (w *ServerInterfaceWrapper) ArticlesListReadArticles(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ArticlesListReadArticlesParams
	// ------------- Optional query parameter "feedId" -------------

	err = runtime.BindQueryParameter("form", false, false, "feedId", ctx.QueryParams(), &params.FeedId)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter feedId: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", false, false, "after", ctx.QueryParams(), &params.After)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after: %s", err))
	}

	// ------------- Optional query parameter "first" -------------

	err = runtime.BindQueryParameter("form", false, false, "first", ctx.QueryParams(), &params.First)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter first: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ArticlesListReadArticles(ctx, params)
	return err
}

// ArticlesListUnreadArticles converts echo context to params.
func (w *ServerInterfaceWrapper) ArticlesListUnreadArticles(ctx echo.Context) error {
	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params ArticlesListUnreadArticlesParams
	// ------------- Optional query parameter "feedId" -------------

	err = runtime.BindQueryParameter("form", false, false, "feedId", ctx.QueryParams(), &params.FeedId)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter feedId: %s", err))
	}

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

	err = runtime.BindQueryParameter("form", false, false, "after", ctx.QueryParams(), &params.After)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter after: %s", err))
	}

	// ------------- Optional query parameter "first" -------------

	err = runtime.BindQueryParameter("form", false, false, "first", ctx.QueryParams(), &params.First)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter first: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ArticlesListUnreadArticles(ctx, params)
	return err
}

// ArticlesGetArticle converts echo context to params.
func (w *ServerInterfaceWrapper) ArticlesGetArticle(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "articleId" -------------
	var articleId string

	err = runtime.BindStyledParameterWithOptions("simple", "articleId", ctx.Param("articleId"), &articleId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter articleId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ArticlesGetArticle(ctx, articleId)
	return err
}

// ArticlesMarkArticleRead converts echo context to params.
func (w *ServerInterfaceWrapper) ArticlesMarkArticleRead(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "articleId" -------------
	var articleId string

	err = runtime.BindStyledParameterWithOptions("simple", "articleId", ctx.Param("articleId"), &articleId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter articleId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ArticlesMarkArticleRead(ctx, articleId)
	return err
}

// ArticlesMarkArticleUnread converts echo context to params.
func (w *ServerInterfaceWrapper) ArticlesMarkArticleUnread(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "articleId" -------------
	var articleId string

	err = runtime.BindStyledParameterWithOptions("simple", "articleId", ctx.Param("articleId"), &articleId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter articleId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ArticlesMarkArticleUnread(ctx, articleId)
	return err
}

// AuthLogin converts echo context to params.
func (w *ServerInterfaceWrapper) AuthLogin(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.AuthLogin(ctx)
	return err
}

// AuthLogout converts echo context to params.
func (w *ServerInterfaceWrapper) AuthLogout(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.AuthLogout(ctx)
	return err
}

// AuthGetCurrentUser converts echo context to params.
func (w *ServerInterfaceWrapper) AuthGetCurrentUser(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.AuthGetCurrentUser(ctx)
	return err
}

// FeedsListFeeds converts echo context to params.
func (w *ServerInterfaceWrapper) FeedsListFeeds(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.FeedsListFeeds(ctx)
	return err
}

// FeedsAddFeed converts echo context to params.
func (w *ServerInterfaceWrapper) FeedsAddFeed(ctx echo.Context) error {
	var err error

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.FeedsAddFeed(ctx)
	return err
}

// FeedsUnsubscribeFeed converts echo context to params.
func (w *ServerInterfaceWrapper) FeedsUnsubscribeFeed(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "feedId" -------------
	var feedId string

	err = runtime.BindStyledParameterWithOptions("simple", "feedId", ctx.Param("feedId"), &feedId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter feedId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.FeedsUnsubscribeFeed(ctx, feedId)
	return err
}

// FeedsGetFeed converts echo context to params.
func (w *ServerInterfaceWrapper) FeedsGetFeed(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "feedId" -------------
	var feedId string

	err = runtime.BindStyledParameterWithOptions("simple", "feedId", ctx.Param("feedId"), &feedId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter feedId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.FeedsGetFeed(ctx, feedId)
	return err
}

// FeedsMarkFeedRead converts echo context to params.
func (w *ServerInterfaceWrapper) FeedsMarkFeedRead(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "feedId" -------------
	var feedId string

	err = runtime.BindStyledParameterWithOptions("simple", "feedId", ctx.Param("feedId"), &feedId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter feedId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.FeedsMarkFeedRead(ctx, feedId)
	return err
}

// FeedsMarkFeedUnread converts echo context to params.
func (w *ServerInterfaceWrapper) FeedsMarkFeedUnread(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "feedId" -------------
	var feedId string

	err = runtime.BindStyledParameterWithOptions("simple", "feedId", ctx.Param("feedId"), &feedId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter feedId: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.FeedsMarkFeedUnread(ctx, feedId)
	return err
}

// This is a simple interface which specifies echo.Route addition functions which
// are present on both echo.Echo and echo.Group, since we want to allow using
// either of them for path registration
type EchoRouter interface {
	CONNECT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	DELETE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	GET(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	HEAD(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	OPTIONS(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	PATCH(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	POST(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	PUT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	TRACE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
}

// RegisterHandlers adds each server route to the EchoRouter.
func RegisterHandlers(router EchoRouter, si ServerInterface) {
	RegisterHandlersWithBaseURL(router, si, "")
}

// Registers handlers, and prepends BaseURL to the paths, so that the paths
// can be served under a prefix.
func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL string) {

	wrapper := ServerInterfaceWrapper{
		Handler: si,
	}

	router.GET(baseURL+"/api/articles/read", wrapper.ArticlesListReadArticles)
	router.GET(baseURL+"/api/articles/unread", wrapper.ArticlesListUnreadArticles)
	router.GET(baseURL+"/api/articles/:articleId", wrapper.ArticlesGetArticle)
	router.POST(baseURL+"/api/articles/:articleId/read", wrapper.ArticlesMarkArticleRead)
	router.POST(baseURL+"/api/articles/:articleId/unread", wrapper.ArticlesMarkArticleUnread)
	router.POST(baseURL+"/api/auth/login", wrapper.AuthLogin)
	router.POST(baseURL+"/api/auth/logout", wrapper.AuthLogout)
	router.GET(baseURL+"/api/auth/me", wrapper.AuthGetCurrentUser)
	router.GET(baseURL+"/api/feeds", wrapper.FeedsListFeeds)
	router.POST(baseURL+"/api/feeds", wrapper.FeedsAddFeed)
	router.DELETE(baseURL+"/api/feeds/:feedId", wrapper.FeedsUnsubscribeFeed)
	router.GET(baseURL+"/api/feeds/:feedId", wrapper.FeedsGetFeed)
	router.POST(baseURL+"/api/feeds/:feedId/read", wrapper.FeedsMarkFeedRead)
	router.POST(baseURL+"/api/feeds/:feedId/unread", wrapper.FeedsMarkFeedUnread)

}

type ArticlesListReadArticlesRequestObject struct {
	Params ArticlesListReadArticlesParams
}

type ArticlesListReadArticlesResponseObject interface {
	VisitArticlesListReadArticlesResponse(w http.ResponseWriter) error
}

type ArticlesListReadArticles200JSONResponse ArticleConnection

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

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

type ArticlesListUnreadArticlesRequestObject struct {
	Params ArticlesListUnreadArticlesParams
}

type ArticlesListUnreadArticlesResponseObject interface {
	VisitArticlesListUnreadArticlesResponse(w http.ResponseWriter) error
}

type ArticlesListUnreadArticles200JSONResponse ArticleConnection

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

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

type ArticlesGetArticleRequestObject struct {
	ArticleId string `json:"articleId"`
}

type ArticlesGetArticleResponseObject interface {
	VisitArticlesGetArticleResponse(w http.ResponseWriter) error
}

type ArticlesGetArticle200JSONResponse Article

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

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

type ArticlesGetArticle404JSONResponse ErrorResponse

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

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

type ArticlesMarkArticleReadRequestObject struct {
	ArticleId string `json:"articleId"`
}

type ArticlesMarkArticleReadResponseObject interface {
	VisitArticlesMarkArticleReadResponse(w http.ResponseWriter) error
}

type ArticlesMarkArticleRead200JSONResponse Article

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

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

type ArticlesMarkArticleRead404JSONResponse ErrorResponse

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

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

type ArticlesMarkArticleUnreadRequestObject struct {
	ArticleId string `json:"articleId"`
}

type ArticlesMarkArticleUnreadResponseObject interface {
	VisitArticlesMarkArticleUnreadResponse(w http.ResponseWriter) error
}

type ArticlesMarkArticleUnread200JSONResponse Article

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

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

type ArticlesMarkArticleUnread404JSONResponse ErrorResponse

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

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

type AuthLoginRequestObject struct {
	Body *AuthLoginJSONRequestBody
}

type AuthLoginResponseObject interface {
	VisitAuthLoginResponse(w http.ResponseWriter) error
}

type AuthLogin200JSONResponse LoginResponse

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

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

type AuthLogin401JSONResponse ErrorResponse

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

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

type AuthLogoutRequestObject struct {
}

type AuthLogoutResponseObject interface {
	VisitAuthLogoutResponse(w http.ResponseWriter) error
}

type AuthLogout204Response struct {
}

func (response AuthLogout204Response) VisitAuthLogoutResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type AuthLogout401JSONResponse ErrorResponse

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

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

type AuthGetCurrentUserRequestObject struct {
}

type AuthGetCurrentUserResponseObject interface {
	VisitAuthGetCurrentUserResponse(w http.ResponseWriter) error
}

type AuthGetCurrentUser200JSONResponse User

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

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

type AuthGetCurrentUser401JSONResponse ErrorResponse

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

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

type FeedsListFeedsRequestObject struct {
}

type FeedsListFeedsResponseObject interface {
	VisitFeedsListFeedsResponse(w http.ResponseWriter) error
}

type FeedsListFeeds200JSONResponse []Feed

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

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

type FeedsAddFeedRequestObject struct {
	Body *FeedsAddFeedJSONRequestBody
}

type FeedsAddFeedResponseObject interface {
	VisitFeedsAddFeedResponse(w http.ResponseWriter) error
}

type FeedsAddFeed201JSONResponse Feed

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

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

type FeedsAddFeed400JSONResponse ErrorResponse

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

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

type FeedsUnsubscribeFeedRequestObject struct {
	FeedId string `json:"feedId"`
}

type FeedsUnsubscribeFeedResponseObject interface {
	VisitFeedsUnsubscribeFeedResponse(w http.ResponseWriter) error
}

type FeedsUnsubscribeFeed204Response struct {
}

func (response FeedsUnsubscribeFeed204Response) VisitFeedsUnsubscribeFeedResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type FeedsUnsubscribeFeed404JSONResponse ErrorResponse

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

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

type FeedsGetFeedRequestObject struct {
	FeedId string `json:"feedId"`
}

type FeedsGetFeedResponseObject interface {
	VisitFeedsGetFeedResponse(w http.ResponseWriter) error
}

type FeedsGetFeed200JSONResponse Feed

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

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

type FeedsGetFeed404JSONResponse ErrorResponse

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

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

type FeedsMarkFeedReadRequestObject struct {
	FeedId string `json:"feedId"`
}

type FeedsMarkFeedReadResponseObject interface {
	VisitFeedsMarkFeedReadResponse(w http.ResponseWriter) error
}

type FeedsMarkFeedRead200JSONResponse Feed

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

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

type FeedsMarkFeedRead404JSONResponse ErrorResponse

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

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

type FeedsMarkFeedUnreadRequestObject struct {
	FeedId string `json:"feedId"`
}

type FeedsMarkFeedUnreadResponseObject interface {
	VisitFeedsMarkFeedUnreadResponse(w http.ResponseWriter) error
}

type FeedsMarkFeedUnread200JSONResponse Feed

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

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

type FeedsMarkFeedUnread404JSONResponse ErrorResponse

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

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

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

	// (GET /api/articles/read)
	ArticlesListReadArticles(ctx context.Context, request ArticlesListReadArticlesRequestObject) (ArticlesListReadArticlesResponseObject, error)

	// (GET /api/articles/unread)
	ArticlesListUnreadArticles(ctx context.Context, request ArticlesListUnreadArticlesRequestObject) (ArticlesListUnreadArticlesResponseObject, error)

	// (GET /api/articles/{articleId})
	ArticlesGetArticle(ctx context.Context, request ArticlesGetArticleRequestObject) (ArticlesGetArticleResponseObject, error)

	// (POST /api/articles/{articleId}/read)
	ArticlesMarkArticleRead(ctx context.Context, request ArticlesMarkArticleReadRequestObject) (ArticlesMarkArticleReadResponseObject, error)

	// (POST /api/articles/{articleId}/unread)
	ArticlesMarkArticleUnread(ctx context.Context, request ArticlesMarkArticleUnreadRequestObject) (ArticlesMarkArticleUnreadResponseObject, error)

	// (POST /api/auth/login)
	AuthLogin(ctx context.Context, request AuthLoginRequestObject) (AuthLoginResponseObject, error)

	// (POST /api/auth/logout)
	AuthLogout(ctx context.Context, request AuthLogoutRequestObject) (AuthLogoutResponseObject, error)

	// (GET /api/auth/me)
	AuthGetCurrentUser(ctx context.Context, request AuthGetCurrentUserRequestObject) (AuthGetCurrentUserResponseObject, error)

	// (GET /api/feeds)
	FeedsListFeeds(ctx context.Context, request FeedsListFeedsRequestObject) (FeedsListFeedsResponseObject, error)

	// (POST /api/feeds)
	FeedsAddFeed(ctx context.Context, request FeedsAddFeedRequestObject) (FeedsAddFeedResponseObject, error)

	// (DELETE /api/feeds/{feedId})
	FeedsUnsubscribeFeed(ctx context.Context, request FeedsUnsubscribeFeedRequestObject) (FeedsUnsubscribeFeedResponseObject, error)

	// (GET /api/feeds/{feedId})
	FeedsGetFeed(ctx context.Context, request FeedsGetFeedRequestObject) (FeedsGetFeedResponseObject, error)

	// (POST /api/feeds/{feedId}/read)
	FeedsMarkFeedRead(ctx context.Context, request FeedsMarkFeedReadRequestObject) (FeedsMarkFeedReadResponseObject, error)

	// (POST /api/feeds/{feedId}/unread)
	FeedsMarkFeedUnread(ctx context.Context, request FeedsMarkFeedUnreadRequestObject) (FeedsMarkFeedUnreadResponseObject, error)
}

type StrictHandlerFunc = strictecho.StrictEchoHandlerFunc
type StrictMiddlewareFunc = strictecho.StrictEchoMiddlewareFunc

func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
}

// ArticlesListReadArticles operation middleware
func (sh *strictHandler) ArticlesListReadArticles(ctx echo.Context, params ArticlesListReadArticlesParams) error {
	var request ArticlesListReadArticlesRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ArticlesListReadArticles(ctx.Request().Context(), request.(ArticlesListReadArticlesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ArticlesListReadArticles")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ArticlesListReadArticlesResponseObject); ok {
		return validResponse.VisitArticlesListReadArticlesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ArticlesListUnreadArticles operation middleware
func (sh *strictHandler) ArticlesListUnreadArticles(ctx echo.Context, params ArticlesListUnreadArticlesParams) error {
	var request ArticlesListUnreadArticlesRequestObject

	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ArticlesListUnreadArticles(ctx.Request().Context(), request.(ArticlesListUnreadArticlesRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ArticlesListUnreadArticles")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ArticlesListUnreadArticlesResponseObject); ok {
		return validResponse.VisitArticlesListUnreadArticlesResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ArticlesGetArticle operation middleware
func (sh *strictHandler) ArticlesGetArticle(ctx echo.Context, articleId string) error {
	var request ArticlesGetArticleRequestObject

	request.ArticleId = articleId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ArticlesGetArticle(ctx.Request().Context(), request.(ArticlesGetArticleRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ArticlesGetArticle")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ArticlesGetArticleResponseObject); ok {
		return validResponse.VisitArticlesGetArticleResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ArticlesMarkArticleRead operation middleware
func (sh *strictHandler) ArticlesMarkArticleRead(ctx echo.Context, articleId string) error {
	var request ArticlesMarkArticleReadRequestObject

	request.ArticleId = articleId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ArticlesMarkArticleRead(ctx.Request().Context(), request.(ArticlesMarkArticleReadRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ArticlesMarkArticleRead")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ArticlesMarkArticleReadResponseObject); ok {
		return validResponse.VisitArticlesMarkArticleReadResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ArticlesMarkArticleUnread operation middleware
func (sh *strictHandler) ArticlesMarkArticleUnread(ctx echo.Context, articleId string) error {
	var request ArticlesMarkArticleUnreadRequestObject

	request.ArticleId = articleId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ArticlesMarkArticleUnread(ctx.Request().Context(), request.(ArticlesMarkArticleUnreadRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ArticlesMarkArticleUnread")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ArticlesMarkArticleUnreadResponseObject); ok {
		return validResponse.VisitArticlesMarkArticleUnreadResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// AuthLogin operation middleware
func (sh *strictHandler) AuthLogin(ctx echo.Context) error {
	var request AuthLoginRequestObject

	var body AuthLoginJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.AuthLogin(ctx.Request().Context(), request.(AuthLoginRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "AuthLogin")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(AuthLoginResponseObject); ok {
		return validResponse.VisitAuthLoginResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// AuthLogout operation middleware
func (sh *strictHandler) AuthLogout(ctx echo.Context) error {
	var request AuthLogoutRequestObject

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.AuthLogout(ctx.Request().Context(), request.(AuthLogoutRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "AuthLogout")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(AuthLogoutResponseObject); ok {
		return validResponse.VisitAuthLogoutResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// AuthGetCurrentUser operation middleware
func (sh *strictHandler) AuthGetCurrentUser(ctx echo.Context) error {
	var request AuthGetCurrentUserRequestObject

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.AuthGetCurrentUser(ctx.Request().Context(), request.(AuthGetCurrentUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "AuthGetCurrentUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(AuthGetCurrentUserResponseObject); ok {
		return validResponse.VisitAuthGetCurrentUserResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// FeedsListFeeds operation middleware
func (sh *strictHandler) FeedsListFeeds(ctx echo.Context) error {
	var request FeedsListFeedsRequestObject

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.FeedsListFeeds(ctx.Request().Context(), request.(FeedsListFeedsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "FeedsListFeeds")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(FeedsListFeedsResponseObject); ok {
		return validResponse.VisitFeedsListFeedsResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// FeedsAddFeed operation middleware
func (sh *strictHandler) FeedsAddFeed(ctx echo.Context) error {
	var request FeedsAddFeedRequestObject

	var body FeedsAddFeedJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.FeedsAddFeed(ctx.Request().Context(), request.(FeedsAddFeedRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "FeedsAddFeed")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(FeedsAddFeedResponseObject); ok {
		return validResponse.VisitFeedsAddFeedResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// FeedsUnsubscribeFeed operation middleware
func (sh *strictHandler) FeedsUnsubscribeFeed(ctx echo.Context, feedId string) error {
	var request FeedsUnsubscribeFeedRequestObject

	request.FeedId = feedId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.FeedsUnsubscribeFeed(ctx.Request().Context(), request.(FeedsUnsubscribeFeedRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "FeedsUnsubscribeFeed")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(FeedsUnsubscribeFeedResponseObject); ok {
		return validResponse.VisitFeedsUnsubscribeFeedResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// FeedsGetFeed operation middleware
func (sh *strictHandler) FeedsGetFeed(ctx echo.Context, feedId string) error {
	var request FeedsGetFeedRequestObject

	request.FeedId = feedId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.FeedsGetFeed(ctx.Request().Context(), request.(FeedsGetFeedRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "FeedsGetFeed")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(FeedsGetFeedResponseObject); ok {
		return validResponse.VisitFeedsGetFeedResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// FeedsMarkFeedRead operation middleware
func (sh *strictHandler) FeedsMarkFeedRead(ctx echo.Context, feedId string) error {
	var request FeedsMarkFeedReadRequestObject

	request.FeedId = feedId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.FeedsMarkFeedRead(ctx.Request().Context(), request.(FeedsMarkFeedReadRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "FeedsMarkFeedRead")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(FeedsMarkFeedReadResponseObject); ok {
		return validResponse.VisitFeedsMarkFeedReadResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// FeedsMarkFeedUnread operation middleware
func (sh *strictHandler) FeedsMarkFeedUnread(ctx echo.Context, feedId string) error {
	var request FeedsMarkFeedUnreadRequestObject

	request.FeedId = feedId

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.FeedsMarkFeedUnread(ctx.Request().Context(), request.(FeedsMarkFeedUnreadRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "FeedsMarkFeedUnread")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(FeedsMarkFeedUnreadResponseObject); ok {
		return validResponse.VisitFeedsMarkFeedUnreadResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}